Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-10 06:01:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

sysctl: treewide: constify the ctl_table argument of proc_handlers

Browse Source 
Summary
 - const qualify struct ctl_table args in proc_handlers:
   This is a prerequisite to moving the static ctl_table structs into .rodata
   data which will ensure that proc_handler function pointers cannot be
   modified.
 -----BEGIN PGP SIGNATURE-----
 
 iQGzBAABCgAdFiEErkcJVyXmMSXOyyeQupfNUreWQU8FAmahVOcACgkQupfNUreW
 QU8QdgwAiDZMEQ6psvDfLGQlOvHyp21exZFC/i1OCrCq4BmTu83iYcojIKSaZ0q6
 pfR9eYTVhNfAGsV2hQJvvUQPSVNESB/A7Z2zGLVQmZcOerAN17L2C7uA1SkbRBel
 P3yoMX6wruVCnBgQTcjktoBgpDqaOiqLTSh8Ko512qYOClLf22sCbbk+doiOwMF6
 zbzh9bRo+qTuTgW30gwzRNml/lA1/XylSsM/cEFCxsc8k22lCneP+iWKDAfWtsr6
 0GL+SvbBTyIEMFFvSw+0MUW30QctxaCYA1pBmn8nmc6eJ2yDly75/r8EWRr7zqDW
 SrRiXYDAzNcW3tiOdC2FW/J95VX62DiSQporVZ/OvahBKpQKGaLLNjx1EE3qGKIk
 ggnYiDmIO88ZBHoRbDDK9EdGGqrIZfRx9JeFD3bMOrwT3Ffxw30rwcYpzlOyjFz3
 TIUeNthGXoQNRxZfTE+iybotKWcXnxCNe4U1Mvc2liY6+Z0jazDWfs+jV7CiuX1G
 Xk8jpTCR
 =JMg4
 -----END PGP SIGNATURE-----

Merge tag 'constfy-sysctl-6.11-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/sysctl/sysctl

Pull sysctl constification from Joel Granados:
 "Treewide constification of the ctl_table argument of proc_handlers
  using a coccinelle script and some manual code formatting fixups.

  This is a prerequisite to moving the static ctl_table structs into
  read-only data section which will ensure that proc_handler function
  pointers cannot be modified"

* tag 'constfy-sysctl-6.11-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/sysctl/sysctl:
  sysctl: treewide: constify the ctl_table argument of proc_handlers
This commit is contained in:
Linus Torvalds 2024-07-25 12:58:36 -07:00
commit b485625078
93 changed files with 258 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/arm64/kernel/armv8_deprecated.c
View File

@ -507,7 +507,7 @@ static int update_insn_emulation_mode(struct insn_emulation *insn,
return ret; return ret;
} }
static int emulation_proc_handler(struct ctl_table *table, int write, static int emulation_proc_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {

2
arch/arm64/kernel/fpsimd.c
View File

@ -535,7 +535,7 @@ static unsigned int find_supported_vector_length(enum vec_type type,
#if defined(CONFIG_ARM64_SVE) && defined(CONFIG_SYSCTL) #if defined(CONFIG_ARM64_SVE) && defined(CONFIG_SYSCTL)
static int vec_proc_do_default_vl(struct ctl_table *table, int write, static int vec_proc_do_default_vl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct vl_info *info = table->extra1; struct vl_info *info = table->extra1;

10
arch/s390/appldata/appldata_base.c
View File

@ -46,9 +46,9 @@
* /proc entries (sysctl) * /proc entries (sysctl)
*/ */
static const char appldata_proc_name[APPLDATA_PROC_NAME_LENGTH] = "appldata"; static const char appldata_proc_name[APPLDATA_PROC_NAME_LENGTH] = "appldata";
static int appldata_timer_handler(struct ctl_table *ctl, int write, static int appldata_timer_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
static int appldata_interval_handler(struct ctl_table *ctl, int write, static int appldata_interval_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
static struct ctl_table_header *appldata_sysctl_header; static struct ctl_table_header *appldata_sysctl_header;
@ -199,7 +199,7 @@ static void __appldata_vtimer_setup(int cmd)
* Start/Stop timer, show status of timer (0 = not active, 1 = active) * Start/Stop timer, show status of timer (0 = not active, 1 = active)
*/ */
static int static int
appldata_timer_handler(struct ctl_table *ctl, int write, appldata_timer_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int timer_active = appldata_timer_active; int timer_active = appldata_timer_active;
@ -232,7 +232,7 @@ appldata_timer_handler(struct ctl_table *ctl, int write,
* current timer interval. * current timer interval.
*/ */
static int static int
appldata_interval_handler(struct ctl_table *ctl, int write, appldata_interval_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int interval = appldata_interval; int interval = appldata_interval;
@ -262,7 +262,7 @@ appldata_interval_handler(struct ctl_table *ctl, int write,
* monitoring (0 = not in process, 1 = in process) * monitoring (0 = not in process, 1 = in process)
*/ */
static int static int
appldata_generic_handler(struct ctl_table *ctl, int write, appldata_generic_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct appldata_ops *ops = NULL, *tmp_ops; struct appldata_ops *ops = NULL, *tmp_ops;

2
arch/s390/kernel/debug.c
View File

@ -954,7 +954,7 @@ static int debug_active = 1;
* always allow read, allow write only if debug_stoppable is set or * always allow read, allow write only if debug_stoppable is set or
* if debug_active is already off * if debug_active is already off
*/ */
static int s390dbf_procactive(struct ctl_table *table, int write, static int s390dbf_procactive(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
if (!write || debug_stoppable || !debug_active) if (!write || debug_stoppable || !debug_active)

2
arch/s390/kernel/topology.c
View File

@ -594,7 +594,7 @@ static int __init topology_setup(char *str)
} }
early_param("topology", topology_setup); early_param("topology", topology_setup);
static int topology_ctl_handler(struct ctl_table *ctl, int write, static int topology_ctl_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int enabled = topology_is_enabled(); int enabled = topology_is_enabled();

6
arch/s390/mm/cmm.c
View File

@ -243,7 +243,7 @@ static int cmm_skip_blanks(char *cp, char **endp)
return str != cp; return str != cp;
} }
static int cmm_pages_handler(struct ctl_table *ctl, int write, static int cmm_pages_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
long nr = cmm_get_pages(); long nr = cmm_get_pages();
@ -262,7 +262,7 @@ static int cmm_pages_handler(struct ctl_table *ctl, int write,
return 0; return 0;
} }
static int cmm_timed_pages_handler(struct ctl_table *ctl, int write, static int cmm_timed_pages_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -282,7 +282,7 @@ static int cmm_timed_pages_handler(struct ctl_table *ctl, int write,
return 0; return 0;
} }
static int cmm_timeout_handler(struct ctl_table *ctl, int write, static int cmm_timeout_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
char buf[64], *p; char buf[64], *p;

2
arch/x86/kernel/itmt.c
View File

@ -38,7 +38,7 @@ static bool __read_mostly sched_itmt_capable;
*/ */
unsigned int __read_mostly sysctl_sched_itmt_enabled; unsigned int __read_mostly sysctl_sched_itmt_enabled;
static int sched_itmt_update_handler(struct ctl_table *table, int write, static int sched_itmt_update_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
unsigned int old_sysctl; unsigned int old_sysctl;

4
drivers/cdrom/cdrom.c
View File

@ -3473,7 +3473,7 @@ static int cdrom_print_info(const char *header, int val, char *info,
return 0; return 0;
} }
static int cdrom_sysctl_info(struct ctl_table *ctl, int write, static int cdrom_sysctl_info(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int pos; int pos;
@ -3586,7 +3586,7 @@ static void cdrom_update_settings(void)
mutex_unlock(&cdrom_mutex); mutex_unlock(&cdrom_mutex);
} }
static int cdrom_sysctl_handler(struct ctl_table *ctl, int write, static int cdrom_sysctl_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

4
drivers/char/random.c
View File

@ -1620,7 +1620,7 @@ static u8 sysctl_bootid[UUID_SIZE];
* UUID. The difference is in whether table->data is NULL; if it is, * UUID. The difference is in whether table->data is NULL; if it is,
* then a new UUID is generated and returned to the user. * then a new UUID is generated and returned to the user.
*/ */
static int proc_do_uuid(struct ctl_table *table, int write, void *buf, static int proc_do_uuid(const struct ctl_table *table, int write, void *buf,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
u8 tmp_uuid[UUID_SIZE], *uuid; u8 tmp_uuid[UUID_SIZE], *uuid;
@ -1651,7 +1651,7 @@ static int proc_do_uuid(struct ctl_table *table, int write, void *buf,
} }
/* The same as proc_dointvec, but writes don't change anything. */ /* The same as proc_dointvec, but writes don't change anything. */
static int proc_do_rointvec(struct ctl_table *table, int write, void *buf, static int proc_do_rointvec(const struct ctl_table *table, int write, void *buf,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
return write ? 0 : proc_dointvec(table, 0, buf, lenp, ppos); return write ? 0 : proc_dointvec(table, 0, buf, lenp, ppos);

2
drivers/macintosh/mac_hid.c
View File

@ -183,7 +183,7 @@ static void mac_hid_stop_emulation(void)
mac_hid_destroy_emumouse(); mac_hid_destroy_emumouse();
} }
static int mac_hid_toggle_emumouse(struct ctl_table *table, int write, static int mac_hid_toggle_emumouse(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *valp = table->data; int *valp = table->data;

2
drivers/net/vrf.c
View File

@ -1886,7 +1886,7 @@ unlock:
return res; return res;
} }
static int vrf_shared_table_handler(struct ctl_table *table, int write, static int vrf_shared_table_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = (struct net *)table->extra1; struct net *net = (struct net *)table->extra1;

12
drivers/parport/procfs.c
View File

@ -33,7 +33,7 @@
#define PARPORT_MIN_SPINTIME_VALUE 1 #define PARPORT_MIN_SPINTIME_VALUE 1
#define PARPORT_MAX_SPINTIME_VALUE 1000 #define PARPORT_MAX_SPINTIME_VALUE 1000
static int do_active_device(struct ctl_table *table, int write, static int do_active_device(const struct ctl_table *table, int write,
void *result, size_t *lenp, loff_t *ppos) void *result, size_t *lenp, loff_t *ppos)
{ {
struct parport *port = (struct parport *)table->extra1; struct parport *port = (struct parport *)table->extra1;
@ -70,7 +70,7 @@ static int do_active_device(struct ctl_table *table, int write,
} }
#ifdef CONFIG_PARPORT_1284 #ifdef CONFIG_PARPORT_1284
static int do_autoprobe(struct ctl_table *table, int write, static int do_autoprobe(const struct ctl_table *table, int write,
void *result, size_t *lenp, loff_t *ppos) void *result, size_t *lenp, loff_t *ppos)
{ {
struct parport_device_info *info = table->extra2; struct parport_device_info *info = table->extra2;
@ -113,7 +113,7 @@ static int do_autoprobe(struct ctl_table *table, int write,
} }
#endif /* IEEE1284.3 support. */ #endif /* IEEE1284.3 support. */
static int do_hardware_base_addr(struct ctl_table *table, int write, static int do_hardware_base_addr(const struct ctl_table *table, int write,
void *result, size_t *lenp, loff_t *ppos) void *result, size_t *lenp, loff_t *ppos)
{ {
struct parport *port = (struct parport *)table->extra1; struct parport *port = (struct parport *)table->extra1;
@ -140,7 +140,7 @@ static int do_hardware_base_addr(struct ctl_table *table, int write,
return 0; return 0;
} }
static int do_hardware_irq(struct ctl_table *table, int write, static int do_hardware_irq(const struct ctl_table *table, int write,
void *result, size_t *lenp, loff_t *ppos) void *result, size_t *lenp, loff_t *ppos)
{ {
struct parport *port = (struct parport *)table->extra1; struct parport *port = (struct parport *)table->extra1;
@ -167,7 +167,7 @@ static int do_hardware_irq(struct ctl_table *table, int write,
return 0; return 0;
} }
static int do_hardware_dma(struct ctl_table *table, int write, static int do_hardware_dma(const struct ctl_table *table, int write,
void *result, size_t *lenp, loff_t *ppos) void *result, size_t *lenp, loff_t *ppos)
{ {
struct parport *port = (struct parport *)table->extra1; struct parport *port = (struct parport *)table->extra1;
@ -194,7 +194,7 @@ static int do_hardware_dma(struct ctl_table *table, int write,
return 0; return 0;
} }
static int do_hardware_modes(struct ctl_table *table, int write, static int do_hardware_modes(const struct ctl_table *table, int write,
void *result, size_t *lenp, loff_t *ppos) void *result, size_t *lenp, loff_t *ppos)
{ {
struct parport *port = (struct parport *)table->extra1; struct parport *port = (struct parport *)table->extra1;

2
drivers/perf/arm_pmuv3.c
View File

@ -1257,7 +1257,7 @@ static void armv8pmu_disable_user_access_ipi(void *unused)
armv8pmu_disable_user_access(); armv8pmu_disable_user_access();
} }
static int armv8pmu_proc_user_access_handler(struct ctl_table *table, int write, static int armv8pmu_proc_user_access_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);

2
drivers/perf/riscv_pmu_sbi.c
View File

@ -1277,7 +1277,7 @@ static void riscv_pmu_update_counter_access(void *info)
csr_write(CSR_SCOUNTEREN, 0x2); csr_write(CSR_SCOUNTEREN, 0x2);
} }
static int riscv_pmu_proc_user_access_handler(struct ctl_table *table, static int riscv_pmu_proc_user_access_handler(const struct ctl_table *table,
int write, void *buffer, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {

2
fs/coredump.c
View File

@ -991,7 +991,7 @@ void validate_coredump_safety(void)
} }
} }
static int proc_dostring_coredump(struct ctl_table *table, int write, static int proc_dostring_coredump(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int error = proc_dostring(table, write, buffer, lenp, ppos); int error = proc_dostring(table, write, buffer, lenp, ppos);

2
fs/dcache.c
View File

@ -177,7 +177,7 @@ static long get_nr_dentry_negative(void)
return sum < 0 ? 0 : sum; return sum < 0 ? 0 : sum;
} }
static int proc_nr_dentry(struct ctl_table *table, int write, void *buffer, static int proc_nr_dentry(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
dentry_stat.nr_dentry = get_nr_dentry(); dentry_stat.nr_dentry = get_nr_dentry();

2
fs/drop_caches.c
View File

@ -48,7 +48,7 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused)
iput(toput_inode); iput(toput_inode);
} }
int drop_caches_sysctl_handler(struct ctl_table *table, int write, int drop_caches_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
int ret; int ret;

2
fs/exec.c
View File

@ -2204,7 +2204,7 @@ COMPAT_SYSCALL_DEFINE5(execveat, int, fd,
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write, static int proc_dointvec_minmax_coredump(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos); int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);

2
fs/file_table.c
View File

@ -96,7 +96,7 @@ EXPORT_SYMBOL_GPL(get_max_files);
/* /*
* Handle nr_files sysctl * Handle nr_files sysctl
*/ */
static int proc_nr_files(struct ctl_table *table, int write, void *buffer, static int proc_nr_files(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
files_stat.nr_files = get_nr_files(); files_stat.nr_files = get_nr_files();

2
fs/fs-writeback.c
View File

@ -2413,7 +2413,7 @@ static int __init start_dirtytime_writeback(void)
} }
__initcall(start_dirtytime_writeback); __initcall(start_dirtytime_writeback);
int dirtytime_interval_handler(struct ctl_table *table, int write, int dirtytime_interval_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

2
fs/inode.c
View File

@ -107,7 +107,7 @@ long get_nr_dirty_inodes(void)
*/ */
static struct inodes_stat_t inodes_stat; static struct inodes_stat_t inodes_stat;
static int proc_nr_inodes(struct ctl_table *table, int write, void *buffer, static int proc_nr_inodes(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
inodes_stat.nr_inodes = get_nr_inodes(); inodes_stat.nr_inodes = get_nr_inodes();

2
fs/pipe.c
View File

@ -1469,7 +1469,7 @@ static int do_proc_dopipe_max_size_conv(unsigned long *lvalp,
return 0; return 0;
} }
static int proc_dopipe_max_size(struct ctl_table *table, int write, static int proc_dopipe_max_size(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return do_proc_douintvec(table, write, buffer, lenp, ppos, return do_proc_douintvec(table, write, buffer, lenp, ppos,

2
fs/quota/dquot.c
View File

@ -2913,7 +2913,7 @@ const struct quotactl_ops dquot_quotactl_sysfile_ops = {
}; };
EXPORT_SYMBOL(dquot_quotactl_sysfile_ops); EXPORT_SYMBOL(dquot_quotactl_sysfile_ops);
static int do_proc_dqstats(struct ctl_table *table, int write, static int do_proc_dqstats(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
unsigned int type = (unsigned long *)table->data - dqstats.stat; unsigned int type = (unsigned long *)table->data - dqstats.stat;

6
fs/xfs/xfs_sysctl.c
View File

@ -11,7 +11,7 @@ static struct ctl_table_header *xfs_table_header;
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
STATIC int STATIC int
xfs_stats_clear_proc_handler( xfs_stats_clear_proc_handler(
struct ctl_table *ctl, const struct ctl_table *ctl,
int write, int write,
void *buffer, void *buffer,
size_t *lenp, size_t *lenp,
@ -31,7 +31,7 @@ xfs_stats_clear_proc_handler(
STATIC int STATIC int
xfs_panic_mask_proc_handler( xfs_panic_mask_proc_handler(
struct ctl_table *ctl, const struct ctl_table *ctl,
int write, int write,
void *buffer, void *buffer,
size_t *lenp, size_t *lenp,
@ -52,7 +52,7 @@ xfs_panic_mask_proc_handler(
STATIC int STATIC int
xfs_deprecated_dointvec_minmax( xfs_deprecated_dointvec_minmax(
struct ctl_table *ctl, const struct ctl_table *ctl,
int write, int write,
void *buffer, void *buffer,
size_t *lenp, size_t *lenp,

4
include/linux/ftrace.h
View File

@ -471,7 +471,7 @@ static inline void arch_ftrace_set_direct_caller(struct ftrace_regs *fregs,
extern int stack_tracer_enabled; extern int stack_tracer_enabled;
int stack_trace_sysctl(struct ctl_table *table, int write, void *buffer, int stack_trace_sysctl(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
/* DO NOT MODIFY THIS VARIABLE DIRECTLY! */ /* DO NOT MODIFY THIS VARIABLE DIRECTLY! */
@ -1175,7 +1175,7 @@ extern int tracepoint_printk;
extern void disable_trace_on_warning(void); extern void disable_trace_on_warning(void);
extern int __disable_trace_on_warning; extern int __disable_trace_on_warning;
int tracepoint_printk_sysctl(struct ctl_table *table, int write, int tracepoint_printk_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
#else /* CONFIG_TRACING */ #else /* CONFIG_TRACING */

8
include/linux/mm.h
View File

@ -204,11 +204,11 @@ extern int sysctl_overcommit_memory;
extern int sysctl_overcommit_ratio; extern int sysctl_overcommit_ratio;
extern unsigned long sysctl_overcommit_kbytes; extern unsigned long sysctl_overcommit_kbytes;
int overcommit_ratio_handler(struct ctl_table *, int, void *, size_t *, int overcommit_ratio_handler(const struct ctl_table *, int, void *, size_t *,
loff_t *); loff_t *);
int overcommit_kbytes_handler(struct ctl_table *, int, void *, size_t *, int overcommit_kbytes_handler(const struct ctl_table *, int, void *, size_t *,
loff_t *); loff_t *);
int overcommit_policy_handler(struct ctl_table *, int, void *, size_t *, int overcommit_policy_handler(const struct ctl_table *, int, void *, size_t *,
loff_t *); loff_t *);
#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP) #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
@ -3854,7 +3854,7 @@ extern bool process_shares_mm(struct task_struct *p, struct mm_struct *mm);
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
extern int sysctl_drop_caches; extern int sysctl_drop_caches;
int drop_caches_sysctl_handler(struct ctl_table *, int, void *, size_t *, int drop_caches_sysctl_handler(const struct ctl_table *, int, void *, size_t *,
loff_t *); loff_t *);
#endif #endif

6
include/linux/perf_event.h
View File

@ -1582,11 +1582,11 @@ extern int sysctl_perf_cpu_time_max_percent;
extern void perf_sample_event_took(u64 sample_len_ns); extern void perf_sample_event_took(u64 sample_len_ns);
int perf_event_max_sample_rate_handler(struct ctl_table *table, int write, int perf_event_max_sample_rate_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write, int perf_cpu_time_max_percent_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
int perf_event_max_stack_handler(struct ctl_table *table, int write, int perf_event_max_stack_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
/* Access to perf_event_open(2) syscall. */ /* Access to perf_event_open(2) syscall. */

2
include/linux/security.h
View File

@ -228,7 +228,7 @@ struct request_sock;
#define LSM_UNSAFE_NO_NEW_PRIVS 4 #define LSM_UNSAFE_NO_NEW_PRIVS 4
#ifdef CONFIG_MMU #ifdef CONFIG_MMU
extern int mmap_min_addr_handler(struct ctl_table *table, int write, extern int mmap_min_addr_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
#endif #endif

34
include/linux/sysctl.h
View File

@ -61,31 +61,31 @@ extern const int sysctl_vals[];
extern const unsigned long sysctl_long_vals[]; extern const unsigned long sysctl_long_vals[];
typedef int proc_handler(struct ctl_table *ctl, int write, void *buffer, typedef int proc_handler(const struct ctl_table *ctl, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
int proc_dostring(struct ctl_table *, int, void *, size_t *, loff_t *); int proc_dostring(const struct ctl_table *, int, void *, size_t *, loff_t *);
int proc_dobool(struct ctl_table *table, int write, void *buffer, int proc_dobool(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
int proc_dointvec(struct ctl_table *, int, void *, size_t *, loff_t *); int proc_dointvec(const struct ctl_table *, int, void *, size_t *, loff_t *);
int proc_douintvec(struct ctl_table *, int, void *, size_t *, loff_t *); int proc_douintvec(const struct ctl_table *, int, void *, size_t *, loff_t *);
int proc_dointvec_minmax(struct ctl_table *, int, void *, size_t *, loff_t *); int proc_dointvec_minmax(const struct ctl_table *, int, void *, size_t *, loff_t *);
int proc_douintvec_minmax(struct ctl_table *table, int write, void *buffer, int proc_douintvec_minmax(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
int proc_dou8vec_minmax(struct ctl_table *table, int write, void *buffer, int proc_dou8vec_minmax(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
int proc_dointvec_jiffies(struct ctl_table *, int, void *, size_t *, loff_t *); int proc_dointvec_jiffies(const struct ctl_table *, int, void *, size_t *, loff_t *);
int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write, int proc_dointvec_ms_jiffies_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
int proc_dointvec_userhz_jiffies(struct ctl_table *, int, void *, size_t *, int proc_dointvec_userhz_jiffies(const struct ctl_table *, int, void *, size_t *,
loff_t *); loff_t *);
int proc_dointvec_ms_jiffies(struct ctl_table *, int, void *, size_t *, int proc_dointvec_ms_jiffies(const struct ctl_table *, int, void *, size_t *,
loff_t *); loff_t *);
int proc_doulongvec_minmax(struct ctl_table *, int, void *, size_t *, loff_t *); int proc_doulongvec_minmax(const struct ctl_table *, int, void *, size_t *, loff_t *);
int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int, void *, int proc_doulongvec_ms_jiffies_minmax(const struct ctl_table *table, int, void *,
size_t *, loff_t *); size_t *, loff_t *);
int proc_do_large_bitmap(struct ctl_table *, int, void *, size_t *, loff_t *); int proc_do_large_bitmap(const struct ctl_table *, int, void *, size_t *, loff_t *);
int proc_do_static_key(struct ctl_table *table, int write, void *buffer, int proc_do_static_key(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
/* /*
@ -287,7 +287,7 @@ static inline bool sysctl_is_alias(char *param)
} }
#endif /* CONFIG_SYSCTL */ #endif /* CONFIG_SYSCTL */
int sysctl_max_threads(struct ctl_table *table, int write, void *buffer, int sysctl_max_threads(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
#endif /* _LINUX_SYSCTL_H */ #endif /* _LINUX_SYSCTL_H */

4
include/linux/vmstat.h
View File

@ -17,7 +17,7 @@ extern int sysctl_stat_interval;
#define DISABLE_NUMA_STAT 0 #define DISABLE_NUMA_STAT 0
extern int sysctl_vm_numa_stat; extern int sysctl_vm_numa_stat;
DECLARE_STATIC_KEY_TRUE(vm_numa_stat_key); DECLARE_STATIC_KEY_TRUE(vm_numa_stat_key);
int sysctl_vm_numa_stat_handler(struct ctl_table *table, int write, int sysctl_vm_numa_stat_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos); void *buffer, size_t *length, loff_t *ppos);
#endif #endif
@ -301,7 +301,7 @@ void cpu_vm_stats_fold(int cpu);
void refresh_zone_stat_thresholds(void); void refresh_zone_stat_thresholds(void);
struct ctl_table; struct ctl_table;
int vmstat_refresh(struct ctl_table *, int write, void *buffer, size_t *lenp, int vmstat_refresh(const struct ctl_table *, int write, void *buffer, size_t *lenp,
loff_t *ppos); loff_t *ppos);
void drain_zonestat(struct zone *zone, struct per_cpu_zonestat *); void drain_zonestat(struct zone *zone, struct per_cpu_zonestat *);

2
include/linux/writeback.h
View File

@ -350,7 +350,7 @@ extern unsigned int dirty_expire_interval;
extern unsigned int dirtytime_expire_interval; extern unsigned int dirtytime_expire_interval;
extern int laptop_mode; extern int laptop_mode;
int dirtytime_interval_handler(struct ctl_table *table, int write, int dirtytime_interval_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty); void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);

2
include/net/ndisc.h
View File

@ -486,7 +486,7 @@ void igmp6_event_report(struct sk_buff *skb);
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, int ndisc_ifinfo_sysctl_change(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
#endif #endif

6
include/net/neighbour.h
View File

@ -412,12 +412,12 @@ void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *,
void *neigh_seq_next(struct seq_file *, void *, loff_t *); void *neigh_seq_next(struct seq_file *, void *, loff_t *);
void neigh_seq_stop(struct seq_file *, void *); void neigh_seq_stop(struct seq_file *, void *);
int neigh_proc_dointvec(struct ctl_table *ctl, int write, int neigh_proc_dointvec(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write, int neigh_proc_dointvec_jiffies(const struct ctl_table *ctl, int write,
void *buffer, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write, int neigh_proc_dointvec_ms_jiffies(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,

2
include/net/netfilter/nf_hooks_lwtunnel.h
View File

@ -2,6 +2,6 @@
#include <linux/types.h> #include <linux/types.h>
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
int nf_hooks_lwtunnel_sysctl_handler(struct ctl_table *table, int write, int nf_hooks_lwtunnel_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
#endif #endif

6
ipc/ipc_sysctl.c
View File

@ -17,7 +17,7 @@
#include <linux/cred.h> #include <linux/cred.h>
#include "util.h" #include "util.h"
static int proc_ipc_dointvec_minmax_orphans(struct ctl_table *table, int write, static int proc_ipc_dointvec_minmax_orphans(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ipc_namespace *ns = struct ipc_namespace *ns =
@ -33,7 +33,7 @@ static int proc_ipc_dointvec_minmax_orphans(struct ctl_table *table, int write,
return err; return err;
} }
static int proc_ipc_auto_msgmni(struct ctl_table *table, int write, static int proc_ipc_auto_msgmni(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table ipc_table; struct ctl_table ipc_table;
@ -48,7 +48,7 @@ static int proc_ipc_auto_msgmni(struct ctl_table *table, int write,
return proc_dointvec_minmax(&ipc_table, write, buffer, lenp, ppos); return proc_dointvec_minmax(&ipc_table, write, buffer, lenp, ppos);
} }
static int proc_ipc_sem_dointvec(struct ctl_table *table, int write, static int proc_ipc_sem_dointvec(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ipc_namespace *ns = struct ipc_namespace *ns =

4
kernel/bpf/syscall.c
View File

@ -5983,7 +5983,7 @@ const struct bpf_prog_ops bpf_syscall_prog_ops = {
}; };
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int bpf_stats_handler(struct ctl_table *table, int write, static int bpf_stats_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct static_key *key = (struct static_key *)table->data; struct static_key *key = (struct static_key *)table->data;
@ -6018,7 +6018,7 @@ void __weak unpriv_ebpf_notify(int new_state)
{ {
} }
static int bpf_unpriv_handler(struct ctl_table *table, int write, static int bpf_unpriv_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret, unpriv_enable = *(int *)table->data; int ret, unpriv_enable = *(int *)table->data;

2
kernel/delayacct.c
View File

@ -44,7 +44,7 @@ void delayacct_init(void)
} }
#ifdef CONFIG_PROC_SYSCTL #ifdef CONFIG_PROC_SYSCTL
static int sysctl_delayacct(struct ctl_table *table, int write, void *buffer, static int sysctl_delayacct(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int state = delayacct_on; int state = delayacct_on;

2
kernel/events/callchain.c
View File

@ -270,7 +270,7 @@ exit_put:
* Used for sysctl_perf_event_max_stack and * Used for sysctl_perf_event_max_stack and
* sysctl_perf_event_max_contexts_per_stack. * sysctl_perf_event_max_contexts_per_stack.
*/ */
int perf_event_max_stack_handler(struct ctl_table *table, int write, int perf_event_max_stack_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *value = table->data; int *value = table->data;

4
kernel/events/core.c
View File

@ -450,7 +450,7 @@ static void update_perf_cpu_limits(void)
static bool perf_rotate_context(struct perf_cpu_pmu_context *cpc); static bool perf_rotate_context(struct perf_cpu_pmu_context *cpc);
int perf_event_max_sample_rate_handler(struct ctl_table *table, int write, int perf_event_max_sample_rate_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;
@ -474,7 +474,7 @@ int perf_event_max_sample_rate_handler(struct ctl_table *table, int write,
int sysctl_perf_cpu_time_max_percent __read_mostly = DEFAULT_CPU_TIME_MAX_PERCENT; int sysctl_perf_cpu_time_max_percent __read_mostly = DEFAULT_CPU_TIME_MAX_PERCENT;
int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write, int perf_cpu_time_max_percent_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);

2
kernel/fork.c
View File

@ -3404,7 +3404,7 @@ int unshare_files(void)
return 0; return 0;
} }
int sysctl_max_threads(struct ctl_table *table, int write, int sysctl_max_threads(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table t; struct ctl_table t;

2
kernel/hung_task.c
View File

@ -239,7 +239,7 @@ static long hung_timeout_jiffies(unsigned long last_checked,
/* /*
* Process updating of timeout sysctl * Process updating of timeout sysctl
*/ */
static int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, static int proc_dohung_task_timeout_secs(const struct ctl_table *table, int write,
void *buffer, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {

2
kernel/kexec_core.c
View File

@ -888,7 +888,7 @@ struct kimage *kexec_crash_image;
static int kexec_load_disabled; static int kexec_load_disabled;
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int kexec_limit_handler(struct ctl_table *table, int write, static int kexec_limit_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct kexec_load_limit *limit = table->data; struct kexec_load_limit *limit = table->data;

2
kernel/kprobes.c
View File

@ -939,7 +939,7 @@ static void unoptimize_all_kprobes(void)
static DEFINE_MUTEX(kprobe_sysctl_mutex); static DEFINE_MUTEX(kprobe_sysctl_mutex);
static int sysctl_kprobes_optimization; static int sysctl_kprobes_optimization;
static int proc_kprobes_optimization_handler(struct ctl_table *table, static int proc_kprobes_optimization_handler(const struct ctl_table *table,
int write, void *buffer, int write, void *buffer,
size_t *length, loff_t *ppos) size_t *length, loff_t *ppos)
{ {

2
kernel/latencytop.c
View File

@ -65,7 +65,7 @@ static struct latency_record latency_record[MAXLR];
int latencytop_enabled; int latencytop_enabled;
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int sysctl_latencytop(struct ctl_table *table, int write, void *buffer, static int sysctl_latencytop(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int err; int err;

2
kernel/pid_namespace.c
View File

@ -261,7 +261,7 @@ void zap_pid_ns_processes(struct pid_namespace *pid_ns)
} }
#ifdef CONFIG_CHECKPOINT_RESTORE #ifdef CONFIG_CHECKPOINT_RESTORE
static int pid_ns_ctl_handler(struct ctl_table *table, int write, static int pid_ns_ctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct pid_namespace *pid_ns = task_active_pid_ns(current); struct pid_namespace *pid_ns = task_active_pid_ns(current);

2
kernel/pid_sysctl.h
View File

@ -5,7 +5,7 @@
#include <linux/pid_namespace.h> #include <linux/pid_namespace.h>
#if defined(CONFIG_SYSCTL) && defined(CONFIG_MEMFD_CREATE) #if defined(CONFIG_SYSCTL) && defined(CONFIG_MEMFD_CREATE)
static int pid_mfd_noexec_dointvec_minmax(struct ctl_table *table, static int pid_mfd_noexec_dointvec_minmax(const struct ctl_table *table,
int write, void *buf, size_t *lenp, loff_t *ppos) int write, void *buf, size_t *lenp, loff_t *ppos)
{ {
struct pid_namespace *ns = task_active_pid_ns(current); struct pid_namespace *ns = task_active_pid_ns(current);

2
kernel/printk/internal.h
View File

@ -8,7 +8,7 @@
#if defined(CONFIG_PRINTK) && defined(CONFIG_SYSCTL) #if defined(CONFIG_PRINTK) && defined(CONFIG_SYSCTL)
void __init printk_sysctl_init(void); void __init printk_sysctl_init(void);
int devkmsg_sysctl_set_loglvl(struct ctl_table *table, int write, int devkmsg_sysctl_set_loglvl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
#else #else
#define printk_sysctl_init() do { } while (0) #define printk_sysctl_init() do { } while (0)

2
kernel/printk/printk.c
View File

@ -197,7 +197,7 @@ __setup("printk.devkmsg=", control_devkmsg);
char devkmsg_log_str[DEVKMSG_STR_MAX_SIZE] = "ratelimit"; char devkmsg_log_str[DEVKMSG_STR_MAX_SIZE] = "ratelimit";
#if defined(CONFIG_PRINTK) && defined(CONFIG_SYSCTL) #if defined(CONFIG_PRINTK) && defined(CONFIG_SYSCTL)
int devkmsg_sysctl_set_loglvl(struct ctl_table *table, int write, int devkmsg_sysctl_set_loglvl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
char old_str[DEVKMSG_STR_MAX_SIZE]; char old_str[DEVKMSG_STR_MAX_SIZE];

2
kernel/printk/sysctl.c
View File

@ -11,7 +11,7 @@
static const int ten_thousand = 10000; static const int ten_thousand = 10000;
static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write, static int proc_dointvec_minmax_sysadmin(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
if (write && !capable(CAP_SYS_ADMIN)) if (write && !capable(CAP_SYS_ADMIN))

6
kernel/sched/core.c
View File

@ -1806,7 +1806,7 @@ static void uclamp_sync_util_min_rt_default(void)
uclamp_update_util_min_rt_default(p); uclamp_update_util_min_rt_default(p);
} }
static int sysctl_sched_uclamp_handler(struct ctl_table *table, int write, static int sysctl_sched_uclamp_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
bool update_root_tg = false; bool update_root_tg = false;
@ -4392,7 +4392,7 @@ static void reset_memory_tiering(void)
} }
} }
static int sysctl_numa_balancing(struct ctl_table *table, int write, static int sysctl_numa_balancing(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table t; struct ctl_table t;
@ -4461,7 +4461,7 @@ out:
__setup("schedstats=", setup_schedstats); __setup("schedstats=", setup_schedstats);
#ifdef CONFIG_PROC_SYSCTL #ifdef CONFIG_PROC_SYSCTL
static int sysctl_schedstats(struct ctl_table *table, int write, void *buffer, static int sysctl_schedstats(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
struct ctl_table t; struct ctl_table t;

8
kernel/sched/rt.c
View File

@ -26,9 +26,9 @@ int sysctl_sched_rt_runtime = 950000;
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int sysctl_sched_rr_timeslice = (MSEC_PER_SEC * RR_TIMESLICE) / HZ; static int sysctl_sched_rr_timeslice = (MSEC_PER_SEC * RR_TIMESLICE) / HZ;
static int sched_rt_handler(struct ctl_table *table, int write, void *buffer, static int sched_rt_handler(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
static int sched_rr_handler(struct ctl_table *table, int write, void *buffer, static int sched_rr_handler(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
static struct ctl_table sched_rt_sysctls[] = { static struct ctl_table sched_rt_sysctls[] = {
{ {
@ -2952,7 +2952,7 @@ static void sched_rt_do_global(void)
raw_spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags); raw_spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
} }
static int sched_rt_handler(struct ctl_table *table, int write, void *buffer, static int sched_rt_handler(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int old_period, old_runtime; int old_period, old_runtime;
@ -2991,7 +2991,7 @@ undo:
return ret; return ret;
} }
static int sched_rr_handler(struct ctl_table *table, int write, void *buffer, static int sched_rr_handler(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

2
kernel/sched/topology.c
View File

@ -285,7 +285,7 @@ void rebuild_sched_domains_energy(void)
} }
#ifdef CONFIG_PROC_SYSCTL #ifdef CONFIG_PROC_SYSCTL
static int sched_energy_aware_handler(struct ctl_table *table, int write, static int sched_energy_aware_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret, state; int ret, state;

2
kernel/seccomp.c
View File

@ -2431,7 +2431,7 @@ static void audit_actions_logged(u32 actions_logged, u32 old_actions_logged,
return audit_seccomp_actions_logged(new, old, !ret); return audit_seccomp_actions_logged(new, old, !ret);
} }
static int seccomp_actions_logged_handler(struct ctl_table *ro_table, int write, static int seccomp_actions_logged_handler(const struct ctl_table *ro_table, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {

2
kernel/stackleak.c
View File

@ -21,7 +21,7 @@
static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass); static DEFINE_STATIC_KEY_FALSE(stack_erasing_bypass);
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int stack_erasing_sysctl(struct ctl_table *table, int write, static int stack_erasing_sysctl(const struct ctl_table *table, int write,
void __user *buffer, size_t *lenp, loff_t *ppos) void __user *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret = 0; int ret = 0;

64
kernel/sysctl.c
View File

@ -256,7 +256,7 @@ static bool proc_first_pos_non_zero_ignore(loff_t *ppos,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_dostring(struct ctl_table *table, int write, int proc_dostring(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
if (write) if (write)
@ -702,7 +702,7 @@ int do_proc_douintvec(const struct ctl_table *table, int write,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_dobool(struct ctl_table *table, int write, void *buffer, int proc_dobool(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
struct ctl_table tmp; struct ctl_table tmp;
@ -739,7 +739,7 @@ int proc_dobool(struct ctl_table *table, int write, void *buffer,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_dointvec(struct ctl_table *table, int write, void *buffer, int proc_dointvec(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL); return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL);
@ -758,7 +758,7 @@ int proc_dointvec(struct ctl_table *table, int write, void *buffer,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_douintvec(struct ctl_table *table, int write, void *buffer, int proc_douintvec(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
return do_proc_douintvec(table, write, buffer, lenp, ppos, return do_proc_douintvec(table, write, buffer, lenp, ppos,
@ -769,7 +769,7 @@ int proc_douintvec(struct ctl_table *table, int write, void *buffer,
* Taint values can only be increased * Taint values can only be increased
* This means we can safely use a temporary. * This means we can safely use a temporary.
*/ */
static int proc_taint(struct ctl_table *table, int write, static int proc_taint(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table t; struct ctl_table t;
@ -864,7 +864,7 @@ static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
* *
* Returns 0 on success or -EINVAL on write when the range check fails. * Returns 0 on success or -EINVAL on write when the range check fails.
*/ */
int proc_dointvec_minmax(struct ctl_table *table, int write, int proc_dointvec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct do_proc_dointvec_minmax_conv_param param = { struct do_proc_dointvec_minmax_conv_param param = {
@ -933,7 +933,7 @@ static int do_proc_douintvec_minmax_conv(unsigned long *lvalp,
* *
* Returns 0 on success or -ERANGE on write when the range check fails. * Returns 0 on success or -ERANGE on write when the range check fails.
*/ */
int proc_douintvec_minmax(struct ctl_table *table, int write, int proc_douintvec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct do_proc_douintvec_minmax_conv_param param = { struct do_proc_douintvec_minmax_conv_param param = {
@ -961,7 +961,7 @@ int proc_douintvec_minmax(struct ctl_table *table, int write,
* *
* Returns 0 on success or an error on write when the range check fails. * Returns 0 on success or an error on write when the range check fails.
*/ */
int proc_dou8vec_minmax(struct ctl_table *table, int write, int proc_dou8vec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table tmp; struct ctl_table tmp;
@ -998,7 +998,7 @@ int proc_dou8vec_minmax(struct ctl_table *table, int write,
EXPORT_SYMBOL_GPL(proc_dou8vec_minmax); EXPORT_SYMBOL_GPL(proc_dou8vec_minmax);
#ifdef CONFIG_MAGIC_SYSRQ #ifdef CONFIG_MAGIC_SYSRQ
static int sysrq_sysctl_handler(struct ctl_table *table, int write, static int sysrq_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int tmp, ret; int tmp, ret;
@ -1115,7 +1115,7 @@ static int do_proc_doulongvec_minmax(const struct ctl_table *table, int write,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_doulongvec_minmax(struct ctl_table *table, int write, int proc_doulongvec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l); return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
@ -1138,7 +1138,7 @@ int proc_doulongvec_minmax(struct ctl_table *table, int write,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, int proc_doulongvec_ms_jiffies_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return do_proc_doulongvec_minmax(table, write, buffer, return do_proc_doulongvec_minmax(table, write, buffer,
@ -1259,14 +1259,14 @@ static int do_proc_dointvec_ms_jiffies_minmax_conv(bool *negp, unsigned long *lv
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_dointvec_jiffies(struct ctl_table *table, int write, int proc_dointvec_jiffies(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return do_proc_dointvec(table,write,buffer,lenp,ppos, return do_proc_dointvec(table,write,buffer,lenp,ppos,
do_proc_dointvec_jiffies_conv,NULL); do_proc_dointvec_jiffies_conv,NULL);
} }
int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write, int proc_dointvec_ms_jiffies_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct do_proc_dointvec_minmax_conv_param param = { struct do_proc_dointvec_minmax_conv_param param = {
@ -1292,7 +1292,7 @@ int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, int proc_dointvec_userhz_jiffies(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return do_proc_dointvec(table, write, buffer, lenp, ppos, return do_proc_dointvec(table, write, buffer, lenp, ppos,
@ -1315,14 +1315,14 @@ int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer, int proc_dointvec_ms_jiffies(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
return do_proc_dointvec(table, write, buffer, lenp, ppos, return do_proc_dointvec(table, write, buffer, lenp, ppos,
do_proc_dointvec_ms_jiffies_conv, NULL); do_proc_dointvec_ms_jiffies_conv, NULL);
} }
static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer, static int proc_do_cad_pid(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
struct pid *new_pid; struct pid *new_pid;
@ -1361,7 +1361,7 @@ static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer,
* *
* Returns 0 on success. * Returns 0 on success.
*/ */
int proc_do_large_bitmap(struct ctl_table *table, int write, int proc_do_large_bitmap(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int err = 0; int err = 0;
@ -1493,85 +1493,85 @@ int proc_do_large_bitmap(struct ctl_table *table, int write,
#else /* CONFIG_PROC_SYSCTL */ #else /* CONFIG_PROC_SYSCTL */
int proc_dostring(struct ctl_table *table, int write, int proc_dostring(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_dobool(struct ctl_table *table, int write, int proc_dobool(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_dointvec(struct ctl_table *table, int write, int proc_dointvec(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_douintvec(struct ctl_table *table, int write, int proc_douintvec(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_dointvec_minmax(struct ctl_table *table, int write, int proc_dointvec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_douintvec_minmax(struct ctl_table *table, int write, int proc_douintvec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_dou8vec_minmax(struct ctl_table *table, int write, int proc_dou8vec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_dointvec_jiffies(struct ctl_table *table, int write, int proc_dointvec_jiffies(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write, int proc_dointvec_ms_jiffies_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, int proc_dointvec_userhz_jiffies(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, int proc_dointvec_ms_jiffies(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_doulongvec_minmax(struct ctl_table *table, int write, int proc_doulongvec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, int proc_doulongvec_ms_jiffies_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
} }
int proc_do_large_bitmap(struct ctl_table *table, int write, int proc_do_large_bitmap(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return -ENOSYS; return -ENOSYS;
@ -1580,7 +1580,7 @@ int proc_do_large_bitmap(struct ctl_table *table, int write,
#endif /* CONFIG_PROC_SYSCTL */ #endif /* CONFIG_PROC_SYSCTL */
#if defined(CONFIG_SYSCTL) #if defined(CONFIG_SYSCTL)
int proc_do_static_key(struct ctl_table *table, int write, int proc_do_static_key(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct static_key *key = (struct static_key *)table->data; struct static_key *key = (struct static_key *)table->data;

2
kernel/time/timer.c
View File

@ -289,7 +289,7 @@ static void timers_update_migration(void)
} }
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int timer_migration_handler(struct ctl_table *table, int write, static int timer_migration_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

2
kernel/trace/ftrace.c
View File

@ -8735,7 +8735,7 @@ static bool is_permanent_ops_registered(void)
} }
static int static int
ftrace_enable_sysctl(struct ctl_table *table, int write, ftrace_enable_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret = -ENODEV; int ret = -ENODEV;

2
kernel/trace/trace.c
View File

@ -2767,7 +2767,7 @@ static void output_printk(struct trace_event_buffer *fbuffer)
raw_spin_unlock_irqrestore(&tracepoint_iter_lock, flags); raw_spin_unlock_irqrestore(&tracepoint_iter_lock, flags);
} }
int tracepoint_printk_sysctl(struct ctl_table *table, int write, int tracepoint_printk_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {

2
kernel/trace/trace_events_user.c
View File

@ -2885,7 +2885,7 @@ err:
return -ENODEV; return -ENODEV;
} }
static int set_max_user_events_sysctl(struct ctl_table *table, int write, static int set_max_user_events_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

2
kernel/trace/trace_stack.c
View File

@ -514,7 +514,7 @@ static const struct file_operations stack_trace_filter_fops = {
#endif /* CONFIG_DYNAMIC_FTRACE */ #endif /* CONFIG_DYNAMIC_FTRACE */
int int
stack_trace_sysctl(struct ctl_table *table, int write, void *buffer, stack_trace_sysctl(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int was_enabled; int was_enabled;

2
kernel/umh.c
View File

@ -495,7 +495,7 @@ int call_usermodehelper(const char *path, char **argv, char **envp, int wait)
EXPORT_SYMBOL(call_usermodehelper); EXPORT_SYMBOL(call_usermodehelper);
#if defined(CONFIG_SYSCTL) #if defined(CONFIG_SYSCTL)
static int proc_cap_handler(struct ctl_table *table, int write, static int proc_cap_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table t; struct ctl_table t;

2
kernel/utsname_sysctl.c
View File

@ -30,7 +30,7 @@ static void *get_uts(const struct ctl_table *table)
* Special case of dostring for the UTS structure. This has locks * Special case of dostring for the UTS structure. This has locks
* to observe. Should this be in kernel/sys.c ???? * to observe. Should this be in kernel/sys.c ????
*/ */
static int proc_do_uts_string(struct ctl_table *table, int write, static int proc_do_uts_string(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table uts_table; struct ctl_table uts_table;

12
kernel/watchdog.c
View File

@ -983,7 +983,7 @@ static void proc_watchdog_update(void)
* -------------------|----------------------------------|------------------------------- * -------------------|----------------------------------|-------------------------------
* proc_soft_watchdog | watchdog_softlockup_user_enabled | WATCHDOG_SOFTOCKUP_ENABLED * proc_soft_watchdog | watchdog_softlockup_user_enabled | WATCHDOG_SOFTOCKUP_ENABLED
*/ */
static int proc_watchdog_common(int which, struct ctl_table *table, int write, static int proc_watchdog_common(int which, const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int err, old, *param = table->data; int err, old, *param = table->data;
@ -1010,7 +1010,7 @@ static int proc_watchdog_common(int which, struct ctl_table *table, int write,
/* /*
* /proc/sys/kernel/watchdog * /proc/sys/kernel/watchdog
*/ */
static int proc_watchdog(struct ctl_table *table, int write, static int proc_watchdog(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return proc_watchdog_common(WATCHDOG_HARDLOCKUP_ENABLED | return proc_watchdog_common(WATCHDOG_HARDLOCKUP_ENABLED |
@ -1021,7 +1021,7 @@ static int proc_watchdog(struct ctl_table *table, int write,
/* /*
* /proc/sys/kernel/nmi_watchdog * /proc/sys/kernel/nmi_watchdog
*/ */
static int proc_nmi_watchdog(struct ctl_table *table, int write, static int proc_nmi_watchdog(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
if (!watchdog_hardlockup_available && write) if (!watchdog_hardlockup_available && write)
@ -1034,7 +1034,7 @@ static int proc_nmi_watchdog(struct ctl_table *table, int write,
/* /*
* /proc/sys/kernel/soft_watchdog * /proc/sys/kernel/soft_watchdog
*/ */
static int proc_soft_watchdog(struct ctl_table *table, int write, static int proc_soft_watchdog(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
return proc_watchdog_common(WATCHDOG_SOFTOCKUP_ENABLED, return proc_watchdog_common(WATCHDOG_SOFTOCKUP_ENABLED,
@ -1045,7 +1045,7 @@ static int proc_soft_watchdog(struct ctl_table *table, int write,
/* /*
* /proc/sys/kernel/watchdog_thresh * /proc/sys/kernel/watchdog_thresh
*/ */
static int proc_watchdog_thresh(struct ctl_table *table, int write, static int proc_watchdog_thresh(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int err, old; int err, old;
@ -1068,7 +1068,7 @@ static int proc_watchdog_thresh(struct ctl_table *table, int write,
* user to specify a mask that will include cpus that have not yet * user to specify a mask that will include cpus that have not yet
* been brought online, if desired. * been brought online, if desired.
*/ */
static int proc_watchdog_cpumask(struct ctl_table *table, int write, static int proc_watchdog_cpumask(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int err; int err;

6
mm/compaction.c
View File

@ -2962,7 +2962,7 @@ static int compact_nodes(void)
return 0; return 0;
} }
static int compaction_proactiveness_sysctl_handler(struct ctl_table *table, int write, static int compaction_proactiveness_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
int rc, nid; int rc, nid;
@ -2992,7 +2992,7 @@ static int compaction_proactiveness_sysctl_handler(struct ctl_table *table, int
* This is the entry point for compacting all nodes via * This is the entry point for compacting all nodes via
* /proc/sys/vm/compact_memory * /proc/sys/vm/compact_memory
*/ */
static int sysctl_compaction_handler(struct ctl_table *table, int write, static int sysctl_compaction_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
int ret; int ret;
@ -3303,7 +3303,7 @@ static int kcompactd_cpu_online(unsigned int cpu)
return 0; return 0;
} }
static int proc_dointvec_minmax_warn_RT_change(struct ctl_table *table, static int proc_dointvec_minmax_warn_RT_change(const struct ctl_table *table,
int write, void *buffer, size_t *lenp, loff_t *ppos) int write, void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret, old; int ret, old;

6
mm/hugetlb.c
View File

@ -4925,7 +4925,7 @@ out:
return ret; return ret;
} }
static int hugetlb_sysctl_handler(struct ctl_table *table, int write, static int hugetlb_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
@ -4934,7 +4934,7 @@ static int hugetlb_sysctl_handler(struct ctl_table *table, int write,
} }
#ifdef CONFIG_NUMA #ifdef CONFIG_NUMA
static int hugetlb_mempolicy_sysctl_handler(struct ctl_table *table, int write, static int hugetlb_mempolicy_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
return hugetlb_sysctl_handler_common(true, table, write, return hugetlb_sysctl_handler_common(true, table, write,
@ -4942,7 +4942,7 @@ static int hugetlb_mempolicy_sysctl_handler(struct ctl_table *table, int write,
} }
#endif /* CONFIG_NUMA */ #endif /* CONFIG_NUMA */
static int hugetlb_overcommit_handler(struct ctl_table *table, int write, static int hugetlb_overcommit_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
struct hstate *h = &default_hstate; struct hstate *h = &default_hstate;

10
mm/page-writeback.c
View File

@ -506,7 +506,7 @@ bool node_dirty_ok(struct pglist_data *pgdat)
} }
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int dirty_background_ratio_handler(struct ctl_table *table, int write, static int dirty_background_ratio_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;
@ -517,7 +517,7 @@ static int dirty_background_ratio_handler(struct ctl_table *table, int write,
return ret; return ret;
} }
static int dirty_background_bytes_handler(struct ctl_table *table, int write, static int dirty_background_bytes_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;
@ -535,7 +535,7 @@ static int dirty_background_bytes_handler(struct ctl_table *table, int write,
return ret; return ret;
} }
static int dirty_ratio_handler(struct ctl_table *table, int write, void *buffer, static int dirty_ratio_handler(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int old_ratio = vm_dirty_ratio; int old_ratio = vm_dirty_ratio;
@ -549,7 +549,7 @@ static int dirty_ratio_handler(struct ctl_table *table, int write, void *buffer,
return ret; return ret;
} }
static int dirty_bytes_handler(struct ctl_table *table, int write, static int dirty_bytes_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
unsigned long old_bytes = vm_dirty_bytes; unsigned long old_bytes = vm_dirty_bytes;
@ -2203,7 +2203,7 @@ bool wb_over_bg_thresh(struct bdi_writeback *wb)
/* /*
* sysctl handler for /proc/sys/vm/dirty_writeback_centisecs * sysctl handler for /proc/sys/vm/dirty_writeback_centisecs
*/ */
static int dirty_writeback_centisecs_handler(struct ctl_table *table, int write, static int dirty_writeback_centisecs_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
unsigned int old_interval = dirty_writeback_interval; unsigned int old_interval = dirty_writeback_interval;

14
mm/page_alloc.c
View File

@ -5127,7 +5127,7 @@ static char numa_zonelist_order[] = "Node";
/* /*
* sysctl handler for numa_zonelist_order * sysctl handler for numa_zonelist_order
*/ */
static int numa_zonelist_order_handler(struct ctl_table *table, int write, static int numa_zonelist_order_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
if (write) if (write)
@ -6091,7 +6091,7 @@ postcore_initcall(init_per_zone_wmark_min)
* that we can call two helper functions whenever min_free_kbytes * that we can call two helper functions whenever min_free_kbytes
* changes. * changes.
*/ */
static int min_free_kbytes_sysctl_handler(struct ctl_table *table, int write, static int min_free_kbytes_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
int rc; int rc;
@ -6107,7 +6107,7 @@ static int min_free_kbytes_sysctl_handler(struct ctl_table *table, int write,
return 0; return 0;
} }
static int watermark_scale_factor_sysctl_handler(struct ctl_table *table, int write, static int watermark_scale_factor_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
int rc; int rc;
@ -6137,7 +6137,7 @@ static void setup_min_unmapped_ratio(void)
} }
static int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *table, int write, static int sysctl_min_unmapped_ratio_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
int rc; int rc;
@ -6164,7 +6164,7 @@ static void setup_min_slab_ratio(void)
sysctl_min_slab_ratio) / 100; sysctl_min_slab_ratio) / 100;
} }
static int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *table, int write, static int sysctl_min_slab_ratio_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
int rc; int rc;
@ -6188,7 +6188,7 @@ static int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *table, int wri
* minimum watermarks. The lowmem reserve ratio can only make sense * minimum watermarks. The lowmem reserve ratio can only make sense
* if in function of the boot time zone sizes. * if in function of the boot time zone sizes.
*/ */
static int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *table, static int lowmem_reserve_ratio_sysctl_handler(const struct ctl_table *table,
int write, void *buffer, size_t *length, loff_t *ppos) int write, void *buffer, size_t *length, loff_t *ppos)
{ {
int i; int i;
@ -6209,7 +6209,7 @@ static int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *table,
* cpu. It is the fraction of total pages in each zone that a hot per cpu * cpu. It is the fraction of total pages in each zone that a hot per cpu
* pagelist can have before it gets flushed back to buddy allocator. * pagelist can have before it gets flushed back to buddy allocator.
*/ */
static int percpu_pagelist_high_fraction_sysctl_handler(struct ctl_table *table, static int percpu_pagelist_high_fraction_sysctl_handler(const struct ctl_table *table,
int write, void *buffer, size_t *length, loff_t *ppos) int write, void *buffer, size_t *length, loff_t *ppos)
{ {
struct zone *zone; struct zone *zone;

6
mm/util.c
View File

@ -868,7 +868,7 @@ int sysctl_max_map_count __read_mostly = DEFAULT_MAX_MAP_COUNT;
unsigned long sysctl_user_reserve_kbytes __read_mostly = 1UL << 17; /* 128MB */ unsigned long sysctl_user_reserve_kbytes __read_mostly = 1UL << 17; /* 128MB */
unsigned long sysctl_admin_reserve_kbytes __read_mostly = 1UL << 13; /* 8MB */ unsigned long sysctl_admin_reserve_kbytes __read_mostly = 1UL << 13; /* 8MB */
int overcommit_ratio_handler(struct ctl_table *table, int write, void *buffer, int overcommit_ratio_handler(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;
@ -884,7 +884,7 @@ static void sync_overcommit_as(struct work_struct *dummy)
percpu_counter_sync(&vm_committed_as); percpu_counter_sync(&vm_committed_as);
} }
int overcommit_policy_handler(struct ctl_table *table, int write, void *buffer, int overcommit_policy_handler(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
struct ctl_table t; struct ctl_table t;
@ -920,7 +920,7 @@ int overcommit_policy_handler(struct ctl_table *table, int write, void *buffer,
return ret; return ret;
} }
int overcommit_kbytes_handler(struct ctl_table *table, int write, void *buffer, int overcommit_kbytes_handler(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

4
mm/vmstat.c
View File

@ -74,7 +74,7 @@ static void invalid_numa_statistics(void)
static DEFINE_MUTEX(vm_numa_stat_lock); static DEFINE_MUTEX(vm_numa_stat_lock);
int sysctl_vm_numa_stat_handler(struct ctl_table *table, int write, int sysctl_vm_numa_stat_handler(const struct ctl_table *table, int write,
void *buffer, size_t *length, loff_t *ppos) void *buffer, size_t *length, loff_t *ppos)
{ {
int ret, oldval; int ret, oldval;
@ -1888,7 +1888,7 @@ static void refresh_vm_stats(struct work_struct *work)
refresh_cpu_vm_stats(true); refresh_cpu_vm_stats(true);
} }
int vmstat_refresh(struct ctl_table *table, int write, int vmstat_refresh(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
long val; long val;

2
net/bridge/br_netfilter_hooks.c
View File

@ -1189,7 +1189,7 @@ int br_nf_hook_thresh(unsigned int hook, struct net *net,
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static static
int brnf_sysctl_call_tables(struct ctl_table *ctl, int write, int brnf_sysctl_call_tables(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

18
net/core/neighbour.c
View File

@ -3543,7 +3543,7 @@ EXPORT_SYMBOL(neigh_app_ns);
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN); static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN);
static int proc_unres_qlen(struct ctl_table *ctl, int write, static int proc_unres_qlen(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int size, ret; int size, ret;
@ -3595,7 +3595,7 @@ static void neigh_proc_update(const struct ctl_table *ctl, int write)
neigh_copy_dflt_parms(net, p, index); neigh_copy_dflt_parms(net, p, index);
} }
static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write, static int neigh_proc_dointvec_zero_intmax(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -3610,7 +3610,7 @@ static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int neigh_proc_dointvec_ms_jiffies_positive(struct ctl_table *ctl, int write, static int neigh_proc_dointvec_ms_jiffies_positive(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table tmp = *ctl; struct ctl_table tmp = *ctl;
@ -3626,7 +3626,7 @@ static int neigh_proc_dointvec_ms_jiffies_positive(struct ctl_table *ctl, int wr
return ret; return ret;
} }
int neigh_proc_dointvec(struct ctl_table *ctl, int write, void *buffer, int neigh_proc_dointvec(const struct ctl_table *ctl, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
@ -3636,7 +3636,7 @@ int neigh_proc_dointvec(struct ctl_table *ctl, int write, void *buffer,
} }
EXPORT_SYMBOL(neigh_proc_dointvec); EXPORT_SYMBOL(neigh_proc_dointvec);
int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write, void *buffer, int neigh_proc_dointvec_jiffies(const struct ctl_table *ctl, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos); int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
@ -3646,7 +3646,7 @@ int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write, void *buffer,
} }
EXPORT_SYMBOL(neigh_proc_dointvec_jiffies); EXPORT_SYMBOL(neigh_proc_dointvec_jiffies);
static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write, static int neigh_proc_dointvec_userhz_jiffies(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -3656,7 +3656,7 @@ static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write,
return ret; return ret;
} }
int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write, int neigh_proc_dointvec_ms_jiffies(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos); int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
@ -3666,7 +3666,7 @@ int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
} }
EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies); EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies);
static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write, static int neigh_proc_dointvec_unres_qlen(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -3676,7 +3676,7 @@ static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int neigh_proc_base_reachable_time(struct ctl_table *ctl, int write, static int neigh_proc_base_reachable_time(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {

20
net/core/sysctl_net_core.c
View File

@ -95,7 +95,7 @@ static struct cpumask *rps_default_mask_cow_alloc(struct net *net)
return rps_default_mask; return rps_default_mask;
} }
static int rps_default_mask_sysctl(struct ctl_table *table, int write, static int rps_default_mask_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = (struct net *)table->data; struct net *net = (struct net *)table->data;
@ -126,7 +126,7 @@ done:
return err; return err;
} }
static int rps_sock_flow_sysctl(struct ctl_table *table, int write, static int rps_sock_flow_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
unsigned int orig_size, size; unsigned int orig_size, size;
@ -198,7 +198,7 @@ static int rps_sock_flow_sysctl(struct ctl_table *table, int write,
#ifdef CONFIG_NET_FLOW_LIMIT #ifdef CONFIG_NET_FLOW_LIMIT
static DEFINE_MUTEX(flow_limit_update_mutex); static DEFINE_MUTEX(flow_limit_update_mutex);
static int flow_limit_cpu_sysctl(struct ctl_table *table, int write, static int flow_limit_cpu_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct sd_flow_limit *cur; struct sd_flow_limit *cur;
@ -255,7 +255,7 @@ done:
return ret; return ret;
} }
static int flow_limit_table_len_sysctl(struct ctl_table *table, int write, static int flow_limit_table_len_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
unsigned int old, *ptr; unsigned int old, *ptr;
@ -277,7 +277,7 @@ static int flow_limit_table_len_sysctl(struct ctl_table *table, int write,
#endif /* CONFIG_NET_FLOW_LIMIT */ #endif /* CONFIG_NET_FLOW_LIMIT */
#ifdef CONFIG_NET_SCHED #ifdef CONFIG_NET_SCHED
static int set_default_qdisc(struct ctl_table *table, int write, static int set_default_qdisc(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
char id[IFNAMSIZ]; char id[IFNAMSIZ];
@ -296,7 +296,7 @@ static int set_default_qdisc(struct ctl_table *table, int write,
} }
#endif #endif
static int proc_do_dev_weight(struct ctl_table *table, int write, static int proc_do_dev_weight(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
static DEFINE_MUTEX(dev_weight_mutex); static DEFINE_MUTEX(dev_weight_mutex);
@ -314,7 +314,7 @@ static int proc_do_dev_weight(struct ctl_table *table, int write,
return ret; return ret;
} }
static int proc_do_rss_key(struct ctl_table *table, int write, static int proc_do_rss_key(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table fake_table; struct ctl_table fake_table;
@ -327,7 +327,7 @@ static int proc_do_rss_key(struct ctl_table *table, int write,
} }
#ifdef CONFIG_BPF_JIT #ifdef CONFIG_BPF_JIT
static int proc_dointvec_minmax_bpf_enable(struct ctl_table *table, int write, static int proc_dointvec_minmax_bpf_enable(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -360,7 +360,7 @@ static int proc_dointvec_minmax_bpf_enable(struct ctl_table *table, int write,
# ifdef CONFIG_HAVE_EBPF_JIT # ifdef CONFIG_HAVE_EBPF_JIT
static int static int
proc_dointvec_minmax_bpf_restricted(struct ctl_table *table, int write, proc_dointvec_minmax_bpf_restricted(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
@ -371,7 +371,7 @@ proc_dointvec_minmax_bpf_restricted(struct ctl_table *table, int write,
# endif /* CONFIG_HAVE_EBPF_JIT */ # endif /* CONFIG_HAVE_EBPF_JIT */
static int static int
proc_dolongvec_minmax_bpf_restricted(struct ctl_table *table, int write, proc_dolongvec_minmax_bpf_restricted(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))

6
net/ipv4/devinet.c
View File

@ -2390,7 +2390,7 @@ static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
} }
} }
static int devinet_conf_proc(struct ctl_table *ctl, int write, static int devinet_conf_proc(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int old_value = *(int *)ctl->data; int old_value = *(int *)ctl->data;
@ -2442,7 +2442,7 @@ static int devinet_conf_proc(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int devinet_sysctl_forward(struct ctl_table *ctl, int write, static int devinet_sysctl_forward(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *valp = ctl->data; int *valp = ctl->data;
@ -2489,7 +2489,7 @@ static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int ipv4_doint_and_flush(struct ctl_table *ctl, int write, static int ipv4_doint_and_flush(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *valp = ctl->data; int *valp = ctl->data;

2
net/ipv4/route.c
View File

@ -3388,7 +3388,7 @@ static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
static int ip_rt_gc_elasticity __read_mostly = 8; static int ip_rt_gc_elasticity __read_mostly = 8;
static int ip_min_valid_pmtu __read_mostly = IPV4_MIN_MTU; static int ip_min_valid_pmtu __read_mostly = IPV4_MIN_MTU;
static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write, static int ipv4_sysctl_rtcache_flush(const struct ctl_table *__ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = (struct net *)__ctl->extra1; struct net *net = (struct net *)__ctl->extra1;

30
net/ipv4/sysctl_net_ipv4.c
View File

@ -62,7 +62,7 @@ static void set_local_port_range(struct net *net, unsigned int low, unsigned int
} }
/* Validate changes from /proc interface. */ /* Validate changes from /proc interface. */
static int ipv4_local_port_range(struct ctl_table *table, int write, static int ipv4_local_port_range(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = table->data; struct net *net = table->data;
@ -96,7 +96,7 @@ static int ipv4_local_port_range(struct ctl_table *table, int write,
} }
/* Validate changes from /proc interface. */ /* Validate changes from /proc interface. */
static int ipv4_privileged_ports(struct ctl_table *table, int write, static int ipv4_privileged_ports(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = container_of(table->data, struct net, struct net *net = container_of(table->data, struct net,
@ -159,7 +159,7 @@ static void set_ping_group_range(const struct ctl_table *table,
} }
/* Validate changes from /proc interface. */ /* Validate changes from /proc interface. */
static int ipv4_ping_group_range(struct ctl_table *table, int write, static int ipv4_ping_group_range(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct user_namespace *user_ns = current_user_ns(); struct user_namespace *user_ns = current_user_ns();
@ -194,7 +194,7 @@ static int ipv4_ping_group_range(struct ctl_table *table, int write,
return ret; return ret;
} }
static int ipv4_fwd_update_priority(struct ctl_table *table, int write, static int ipv4_fwd_update_priority(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net; struct net *net;
@ -210,7 +210,7 @@ static int ipv4_fwd_update_priority(struct ctl_table *table, int write,
return ret; return ret;
} }
static int proc_tcp_congestion_control(struct ctl_table *ctl, int write, static int proc_tcp_congestion_control(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = container_of(ctl->data, struct net, struct net *net = container_of(ctl->data, struct net,
@ -230,7 +230,7 @@ static int proc_tcp_congestion_control(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int proc_tcp_available_congestion_control(struct ctl_table *ctl, static int proc_tcp_available_congestion_control(const struct ctl_table *ctl,
int write, void *buffer, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
@ -246,7 +246,7 @@ static int proc_tcp_available_congestion_control(struct ctl_table *ctl,
return ret; return ret;
} }
static int proc_allowed_congestion_control(struct ctl_table *ctl, static int proc_allowed_congestion_control(const struct ctl_table *ctl,
int write, void *buffer, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
@ -283,7 +283,7 @@ static int sscanf_key(char *buf, __le32 *key)
return ret; return ret;
} }
static int proc_tcp_fastopen_key(struct ctl_table *table, int write, static int proc_tcp_fastopen_key(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = container_of(table->data, struct net, struct net *net = container_of(table->data, struct net,
@ -354,7 +354,7 @@ bad_key:
return ret; return ret;
} }
static int proc_tfo_blackhole_detect_timeout(struct ctl_table *table, static int proc_tfo_blackhole_detect_timeout(const struct ctl_table *table,
int write, void *buffer, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
@ -369,7 +369,7 @@ static int proc_tfo_blackhole_detect_timeout(struct ctl_table *table,
return ret; return ret;
} }
static int proc_tcp_available_ulp(struct ctl_table *ctl, static int proc_tcp_available_ulp(const struct ctl_table *ctl,
int write, void *buffer, size_t *lenp, int write, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -386,7 +386,7 @@ static int proc_tcp_available_ulp(struct ctl_table *ctl,
return ret; return ret;
} }
static int proc_tcp_ehash_entries(struct ctl_table *table, int write, static int proc_tcp_ehash_entries(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = container_of(table->data, struct net, struct net *net = container_of(table->data, struct net,
@ -410,7 +410,7 @@ static int proc_tcp_ehash_entries(struct ctl_table *table, int write,
return proc_dointvec(&tbl, write, buffer, lenp, ppos); return proc_dointvec(&tbl, write, buffer, lenp, ppos);
} }
static int proc_udp_hash_entries(struct ctl_table *table, int write, static int proc_udp_hash_entries(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = container_of(table->data, struct net, struct net *net = container_of(table->data, struct net,
@ -434,7 +434,7 @@ static int proc_udp_hash_entries(struct ctl_table *table, int write,
} }
#ifdef CONFIG_IP_ROUTE_MULTIPATH #ifdef CONFIG_IP_ROUTE_MULTIPATH
static int proc_fib_multipath_hash_policy(struct ctl_table *table, int write, static int proc_fib_multipath_hash_policy(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -449,7 +449,7 @@ static int proc_fib_multipath_hash_policy(struct ctl_table *table, int write,
return ret; return ret;
} }
static int proc_fib_multipath_hash_fields(struct ctl_table *table, int write, static int proc_fib_multipath_hash_fields(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -484,7 +484,7 @@ static void proc_fib_multipath_hash_set_seed(struct net *net, u32 user_seed)
WRITE_ONCE(net->ipv4.sysctl_fib_multipath_hash_seed, new); WRITE_ONCE(net->ipv4.sysctl_fib_multipath_hash_seed, new);
} }
static int proc_fib_multipath_hash_seed(struct ctl_table *table, int write, static int proc_fib_multipath_hash_seed(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {

16
net/ipv6/addrconf.c
View File

@ -6309,7 +6309,7 @@ static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int addrconf_sysctl_forward(struct ctl_table *ctl, int write, static int addrconf_sysctl_forward(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *valp = ctl->data; int *valp = ctl->data;
@ -6334,7 +6334,7 @@ static int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int addrconf_sysctl_mtu(struct ctl_table *ctl, int write, static int addrconf_sysctl_mtu(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct inet6_dev *idev = ctl->extra1; struct inet6_dev *idev = ctl->extra1;
@ -6405,7 +6405,7 @@ static int addrconf_disable_ipv6(const struct ctl_table *table, int *p, int newf
return 0; return 0;
} }
static int addrconf_sysctl_disable(struct ctl_table *ctl, int write, static int addrconf_sysctl_disable(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *valp = ctl->data; int *valp = ctl->data;
@ -6430,7 +6430,7 @@ static int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write, static int addrconf_sysctl_proxy_ndp(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *valp = ctl->data; int *valp = ctl->data;
@ -6471,7 +6471,7 @@ static int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int addrconf_sysctl_addr_gen_mode(struct ctl_table *ctl, int write, static int addrconf_sysctl_addr_gen_mode(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -6534,7 +6534,7 @@ out:
return ret; return ret;
} }
static int addrconf_sysctl_stable_secret(struct ctl_table *ctl, int write, static int addrconf_sysctl_stable_secret(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
@ -6602,7 +6602,7 @@ out:
} }
static static
int addrconf_sysctl_ignore_routes_with_linkdown(struct ctl_table *ctl, int addrconf_sysctl_ignore_routes_with_linkdown(const struct ctl_table *ctl,
int write, void *buffer, int write, void *buffer,
size_t *lenp, size_t *lenp,
loff_t *ppos) loff_t *ppos)
@ -6702,7 +6702,7 @@ int addrconf_disable_policy(const struct ctl_table *ctl, int *valp, int val)
return 0; return 0;
} }
static int addrconf_sysctl_disable_policy(struct ctl_table *ctl, int write, static int addrconf_sysctl_disable_policy(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *valp = ctl->data; int *valp = ctl->data;

2
net/ipv6/ndisc.c
View File

@ -1951,7 +1951,7 @@ static void ndisc_warn_deprecated_sysctl(const struct ctl_table *ctl,
} }
} }
int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void *buffer, int ndisc_ifinfo_sysctl_change(const struct ctl_table *ctl, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
struct net_device *dev = ctl->extra1; struct net_device *dev = ctl->extra1;

2
net/ipv6/route.c
View File

@ -6334,7 +6334,7 @@ static int rt6_stats_seq_show(struct seq_file *seq, void *v)
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write, static int ipv6_sysctl_rtcache_flush(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net; struct net *net;

4
net/ipv6/sysctl_net_ipv6.c
View File

@ -30,7 +30,7 @@ static u32 rt6_multipath_hash_fields_all_mask =
static u32 ioam6_id_max = IOAM6_DEFAULT_ID; static u32 ioam6_id_max = IOAM6_DEFAULT_ID;
static u64 ioam6_id_wide_max = IOAM6_DEFAULT_ID_WIDE; static u64 ioam6_id_wide_max = IOAM6_DEFAULT_ID_WIDE;
static int proc_rt6_multipath_hash_policy(struct ctl_table *table, int write, static int proc_rt6_multipath_hash_policy(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net; struct net *net;
@ -46,7 +46,7 @@ static int proc_rt6_multipath_hash_policy(struct ctl_table *table, int write,
} }
static int static int
proc_rt6_multipath_hash_fields(struct ctl_table *table, int write, void *buffer, proc_rt6_multipath_hash_fields(const struct ctl_table *table, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {
struct net *net; struct net *net;

4
net/mpls/af_mpls.c
View File

@ -1347,7 +1347,7 @@ static int mpls_netconf_dump_devconf(struct sk_buff *skb,
#define MPLS_PERDEV_SYSCTL_OFFSET(field) \ #define MPLS_PERDEV_SYSCTL_OFFSET(field) \
(&((struct mpls_dev *)0)->field) (&((struct mpls_dev *)0)->field)
static int mpls_conf_proc(struct ctl_table *ctl, int write, static int mpls_conf_proc(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int oval = *(int *)ctl->data; int oval = *(int *)ctl->data;
@ -2600,7 +2600,7 @@ nolabels:
return -ENOMEM; return -ENOMEM;
} }
static int mpls_platform_labels(struct ctl_table *table, int write, static int mpls_platform_labels(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = table->data; struct net *net = table->data;

4
net/mptcp/ctrl.c
View File

@ -113,7 +113,7 @@ static int mptcp_set_scheduler(const struct net *net, const char *name)
return ret; return ret;
} }
static int proc_scheduler(struct ctl_table *ctl, int write, static int proc_scheduler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
const struct net *net = current->nsproxy->net_ns; const struct net *net = current->nsproxy->net_ns;
@ -133,7 +133,7 @@ static int proc_scheduler(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int proc_available_schedulers(struct ctl_table *ctl, static int proc_available_schedulers(const struct ctl_table *ctl,
int write, void *buffer, int write, void *buffer,
size_t *lenp, loff_t *ppos) size_t *lenp, loff_t *ppos)
{ {

12
net/netfilter/ipvs/ip_vs_ctl.c
View File

@ -1846,7 +1846,7 @@ static int ip_vs_zero_all(struct netns_ipvs *ipvs)
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int static int
proc_do_defense_mode(struct ctl_table *table, int write, proc_do_defense_mode(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct netns_ipvs *ipvs = table->extra2; struct netns_ipvs *ipvs = table->extra2;
@ -1873,7 +1873,7 @@ proc_do_defense_mode(struct ctl_table *table, int write,
} }
static int static int
proc_do_sync_threshold(struct ctl_table *table, int write, proc_do_sync_threshold(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct netns_ipvs *ipvs = table->extra2; struct netns_ipvs *ipvs = table->extra2;
@ -1901,7 +1901,7 @@ proc_do_sync_threshold(struct ctl_table *table, int write,
} }
static int static int
proc_do_sync_ports(struct ctl_table *table, int write, proc_do_sync_ports(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int *valp = table->data; int *valp = table->data;
@ -1984,7 +1984,7 @@ static int ipvs_proc_est_cpumask_get(const struct ctl_table *table,
return ret; return ret;
} }
static int ipvs_proc_est_cpulist(struct ctl_table *table, int write, static int ipvs_proc_est_cpulist(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;
@ -2011,7 +2011,7 @@ static int ipvs_proc_est_cpulist(struct ctl_table *table, int write,
return ret; return ret;
} }
static int ipvs_proc_est_nice(struct ctl_table *table, int write, static int ipvs_proc_est_nice(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct netns_ipvs *ipvs = table->extra2; struct netns_ipvs *ipvs = table->extra2;
@ -2041,7 +2041,7 @@ static int ipvs_proc_est_nice(struct ctl_table *table, int write,
return ret; return ret;
} }
static int ipvs_proc_run_estimation(struct ctl_table *table, int write, static int ipvs_proc_run_estimation(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct netns_ipvs *ipvs = table->extra2; struct netns_ipvs *ipvs = table->extra2;

2
net/netfilter/nf_conntrack_standalone.c
View File

@ -524,7 +524,7 @@ EXPORT_SYMBOL_GPL(nf_conntrack_count);
static unsigned int nf_conntrack_htable_size_user __read_mostly; static unsigned int nf_conntrack_htable_size_user __read_mostly;
static int static int
nf_conntrack_hash_sysctl(struct ctl_table *table, int write, nf_conntrack_hash_sysctl(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

2
net/netfilter/nf_hooks_lwtunnel.c
View File

@ -28,7 +28,7 @@ static inline int nf_hooks_lwtunnel_set(int enable)
} }
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
int nf_hooks_lwtunnel_sysctl_handler(struct ctl_table *table, int write, int nf_hooks_lwtunnel_sysctl_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int proc_nf_hooks_lwtunnel_enabled = 0; int proc_nf_hooks_lwtunnel_enabled = 0;

2
net/netfilter/nf_log.c
View File

@ -408,7 +408,7 @@ static struct ctl_table nf_log_sysctl_ftable[] = {
}, },
}; };
static int nf_log_proc_dostring(struct ctl_table *table, int write, static int nf_log_proc_dostring(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
const struct nf_logger *logger; const struct nf_logger *logger;

2
net/phonet/sysctl.c
View File

@ -48,7 +48,7 @@ void phonet_get_local_port_range(int *min, int *max)
} while (read_seqretry(&local_port_range_lock, seq)); } while (read_seqretry(&local_port_range_lock, seq));
} }
static int proc_local_port_range(struct ctl_table *table, int write, static int proc_local_port_range(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

4
net/rds/tcp.c
View File

@ -61,7 +61,7 @@ static atomic_t rds_tcp_unloading = ATOMIC_INIT(0);
static struct kmem_cache *rds_tcp_conn_slab; static struct kmem_cache *rds_tcp_conn_slab;
static int rds_tcp_skbuf_handler(struct ctl_table *ctl, int write, static int rds_tcp_skbuf_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *fpos); void *buffer, size_t *lenp, loff_t *fpos);
static int rds_tcp_min_sndbuf = SOCK_MIN_SNDBUF; static int rds_tcp_min_sndbuf = SOCK_MIN_SNDBUF;
@ -682,7 +682,7 @@ static void rds_tcp_sysctl_reset(struct net *net)
spin_unlock_irq(&rds_tcp_conn_lock); spin_unlock_irq(&rds_tcp_conn_lock);
} }
static int rds_tcp_skbuf_handler(struct ctl_table *ctl, int write, static int rds_tcp_skbuf_handler(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *fpos) void *buffer, size_t *lenp, loff_t *fpos)
{ {
struct net *net = current->nsproxy->net_ns; struct net *net = current->nsproxy->net_ns;

28
net/sctp/sysctl.c
View File

@ -43,19 +43,19 @@ static unsigned long max_autoclose_max =
(MAX_SCHEDULE_TIMEOUT / HZ > UINT_MAX) (MAX_SCHEDULE_TIMEOUT / HZ > UINT_MAX)
? UINT_MAX : MAX_SCHEDULE_TIMEOUT / HZ; ? UINT_MAX : MAX_SCHEDULE_TIMEOUT / HZ;
static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write, static int proc_sctp_do_hmac_alg(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write, static int proc_sctp_do_rto_min(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write, void *buffer, static int proc_sctp_do_rto_max(const struct ctl_table *ctl, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
static int proc_sctp_do_udp_port(struct ctl_table *ctl, int write, void *buffer, static int proc_sctp_do_udp_port(const struct ctl_table *ctl, int write, void *buffer,
size_t *lenp, loff_t *ppos); size_t *lenp, loff_t *ppos);
static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write, static int proc_sctp_do_alpha_beta(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
static int proc_sctp_do_auth(struct ctl_table *ctl, int write, static int proc_sctp_do_auth(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
static int proc_sctp_do_probe_interval(struct ctl_table *ctl, int write, static int proc_sctp_do_probe_interval(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos); void *buffer, size_t *lenp, loff_t *ppos);
static struct ctl_table sctp_table[] = { static struct ctl_table sctp_table[] = {
@ -384,7 +384,7 @@ static struct ctl_table sctp_net_table[] = {
}, },
}; };
static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write, static int proc_sctp_do_hmac_alg(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = current->nsproxy->net_ns; struct net *net = current->nsproxy->net_ns;
@ -429,7 +429,7 @@ static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write, static int proc_sctp_do_rto_min(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = current->nsproxy->net_ns; struct net *net = current->nsproxy->net_ns;
@ -457,7 +457,7 @@ static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write, static int proc_sctp_do_rto_max(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = current->nsproxy->net_ns; struct net *net = current->nsproxy->net_ns;
@ -485,7 +485,7 @@ static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write, static int proc_sctp_do_alpha_beta(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
if (write) if (write)
@ -495,7 +495,7 @@ static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
return proc_dointvec_minmax(ctl, write, buffer, lenp, ppos); return proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
} }
static int proc_sctp_do_auth(struct ctl_table *ctl, int write, static int proc_sctp_do_auth(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = current->nsproxy->net_ns; struct net *net = current->nsproxy->net_ns;
@ -524,7 +524,7 @@ static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int proc_sctp_do_udp_port(struct ctl_table *ctl, int write, static int proc_sctp_do_udp_port(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = current->nsproxy->net_ns; struct net *net = current->nsproxy->net_ns;
@ -565,7 +565,7 @@ static int proc_sctp_do_udp_port(struct ctl_table *ctl, int write,
return ret; return ret;
} }
static int proc_sctp_do_probe_interval(struct ctl_table *ctl, int write, static int proc_sctp_do_probe_interval(const struct ctl_table *ctl, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct net *net = current->nsproxy->net_ns; struct net *net = current->nsproxy->net_ns;

4
net/sunrpc/sysctl.c
View File

@ -40,7 +40,7 @@ EXPORT_SYMBOL_GPL(nlm_debug);
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG) #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
static int proc_do_xprt(struct ctl_table *table, int write, static int proc_do_xprt(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
char tmpbuf[256]; char tmpbuf[256];
@ -62,7 +62,7 @@ static int proc_do_xprt(struct ctl_table *table, int write,
} }
static int static int
proc_dodebug(struct ctl_table *table, int write, void *buffer, size_t *lenp, proc_dodebug(const struct ctl_table *table, int write, void *buffer, size_t *lenp,
loff_t *ppos) loff_t *ppos)
{ {
char tmpbuf[20], *s = NULL; char tmpbuf[20], *s = NULL;

2
net/sunrpc/xprtrdma/svc_rdma.c
View File

@ -74,7 +74,7 @@ enum {
SVCRDMA_COUNTER_BUFSIZ = sizeof(unsigned long long), SVCRDMA_COUNTER_BUFSIZ = sizeof(unsigned long long),
}; };
static int svcrdma_counter_handler(struct ctl_table *table, int write, static int svcrdma_counter_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct percpu_counter *stat = (struct percpu_counter *)table->data; struct percpu_counter *stat = (struct percpu_counter *)table->data;

2
security/apparmor/lsm.c
View File

@ -2029,7 +2029,7 @@ static int __init alloc_buffers(void)
} }
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int apparmor_dointvec(struct ctl_table *table, int write, static int apparmor_dointvec(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
if (!aa_current_policy_admin_capable(NULL)) if (!aa_current_policy_admin_capable(NULL))

2
security/min_addr.c
View File

@ -29,7 +29,7 @@ static void update_mmap_min_addr(void)
* sysctl handler which just sets dac_mmap_min_addr = the new value and then * sysctl handler which just sets dac_mmap_min_addr = the new value and then
* calls update_mmap_min_addr() so non MAP_FIXED hints get rounded properly * calls update_mmap_min_addr() so non MAP_FIXED hints get rounded properly
*/ */
int mmap_min_addr_handler(struct ctl_table *table, int write, int mmap_min_addr_handler(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
int ret; int ret;

2
security/yama/yama_lsm.c
View File

@ -436,7 +436,7 @@ static struct security_hook_list yama_hooks[] __ro_after_init = {
}; };
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL
static int yama_dointvec_minmax(struct ctl_table *table, int write, static int yama_dointvec_minmax(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos) void *buffer, size_t *lenp, loff_t *ppos)
{ {
struct ctl_table table_copy; struct ctl_table table_copy;