sysctl: remove "struct file *" argument of ->proc_handler

+7 -7

arch/frv/kernel/pm.c

··· 150 150 /* 151 151 * Send us to sleep. 152 152 */ 153 - static int sysctl_pm_do_suspend(ctl_table *ctl, int write, struct file *filp, 153 + static int sysctl_pm_do_suspend(ctl_table *ctl, int write, 154 154 void __user *buffer, size_t *lenp, loff_t *fpos) 155 155 { 156 156 int retval, mode; ··· 198 198 } 199 199 200 200 201 - static int cmode_procctl(ctl_table *ctl, int write, struct file *filp, 201 + static int cmode_procctl(ctl_table *ctl, int write, 202 202 void __user *buffer, size_t *lenp, loff_t *fpos) 203 203 { 204 204 int new_cmode; 205 205 206 206 if (!write) 207 - return proc_dointvec(ctl, write, filp, buffer, lenp, fpos); 207 + return proc_dointvec(ctl, write, buffer, lenp, fpos); 208 208 209 209 new_cmode = user_atoi(buffer, *lenp); 210 210 ··· 301 301 return 0; 302 302 } 303 303 304 - static int p0_procctl(ctl_table *ctl, int write, struct file *filp, 304 + static int p0_procctl(ctl_table *ctl, int write, 305 305 void __user *buffer, size_t *lenp, loff_t *fpos) 306 306 { 307 307 int new_p0; 308 308 309 309 if (!write) 310 - return proc_dointvec(ctl, write, filp, buffer, lenp, fpos); 310 + return proc_dointvec(ctl, write, buffer, lenp, fpos); 311 311 312 312 new_p0 = user_atoi(buffer, *lenp); 313 313 ··· 345 345 return 1; 346 346 } 347 347 348 - static int cm_procctl(ctl_table *ctl, int write, struct file *filp, 348 + static int cm_procctl(ctl_table *ctl, int write, 349 349 void __user *buffer, size_t *lenp, loff_t *fpos) 350 350 { 351 351 int new_cm; 352 352 353 353 if (!write) 354 - return proc_dointvec(ctl, write, filp, buffer, lenp, fpos); 354 + return proc_dointvec(ctl, write, buffer, lenp, fpos); 355 355 356 356 new_cm = user_atoi(buffer, *lenp); 357 357

+9 -9

arch/mips/lasat/sysctl.c

··· 56 56 57 57 58 58 /* And the same for proc */ 59 - int proc_dolasatstring(ctl_table *table, int write, struct file *filp, 59 + int proc_dolasatstring(ctl_table *table, int write, 60 60 void *buffer, size_t *lenp, loff_t *ppos) 61 61 { 62 62 int r; 63 63 64 - r = proc_dostring(table, write, filp, buffer, lenp, ppos); 64 + r = proc_dostring(table, write, buffer, lenp, ppos); 65 65 if ((!write) || r) 66 66 return r; 67 67 ··· 71 71 } 72 72 73 73 /* proc function to write EEPROM after changing int entry */ 74 - int proc_dolasatint(ctl_table *table, int write, struct file *filp, 74 + int proc_dolasatint(ctl_table *table, int write, 75 75 void *buffer, size_t *lenp, loff_t *ppos) 76 76 { 77 77 int r; 78 78 79 - r = proc_dointvec(table, write, filp, buffer, lenp, ppos); 79 + r = proc_dointvec(table, write, buffer, lenp, ppos); 80 80 if ((!write) || r) 81 81 return r; 82 82 ··· 89 89 static int rtctmp; 90 90 91 91 /* proc function to read/write RealTime Clock */ 92 - int proc_dolasatrtc(ctl_table *table, int write, struct file *filp, 92 + int proc_dolasatrtc(ctl_table *table, int write, 93 93 void *buffer, size_t *lenp, loff_t *ppos) 94 94 { 95 95 struct timespec ts; ··· 102 102 if (rtctmp < 0) 103 103 rtctmp = 0; 104 104 } 105 - r = proc_dointvec(table, write, filp, buffer, lenp, ppos); 105 + r = proc_dointvec(table, write, buffer, lenp, ppos); 106 106 if (r) 107 107 return r; 108 108 ··· 154 154 #endif 155 155 156 156 #ifdef CONFIG_INET 157 - int proc_lasat_ip(ctl_table *table, int write, struct file *filp, 157 + int proc_lasat_ip(ctl_table *table, int write, 158 158 void *buffer, size_t *lenp, loff_t *ppos) 159 159 { 160 160 unsigned int ip; ··· 231 231 return 0; 232 232 } 233 233 234 - int proc_lasat_prid(ctl_table *table, int write, struct file *filp, 234 + int proc_lasat_prid(ctl_table *table, int write, 235 235 void *buffer, size_t *lenp, loff_t *ppos) 236 236 { 237 237 int r; 238 238 239 - r = proc_dointvec(table, write, filp, buffer, lenp, ppos); 239 + r = proc_dointvec(table, write, buffer, lenp, ppos); 240 240 if (r < 0) 241 241 return r; 242 242 if (write) {

+4 -5

arch/s390/appldata/appldata_base.c

··· 50 50 * /proc entries (sysctl) 51 51 */ 52 52 static const char appldata_proc_name[APPLDATA_PROC_NAME_LENGTH] = "appldata"; 53 - static int appldata_timer_handler(ctl_table *ctl, int write, struct file *filp, 53 + static int appldata_timer_handler(ctl_table *ctl, int write, 54 54 void __user *buffer, size_t *lenp, loff_t *ppos); 55 55 static int appldata_interval_handler(ctl_table *ctl, int write, 56 - struct file *filp, 57 56 void __user *buffer, 58 57 size_t *lenp, loff_t *ppos); 59 58 ··· 246 247 * Start/Stop timer, show status of timer (0 = not active, 1 = active) 247 248 */ 248 249 static int 249 - appldata_timer_handler(ctl_table *ctl, int write, struct file *filp, 250 + appldata_timer_handler(ctl_table *ctl, int write, 250 251 void __user *buffer, size_t *lenp, loff_t *ppos) 251 252 { 252 253 int len; ··· 288 289 * current timer interval. 289 290 */ 290 291 static int 291 - appldata_interval_handler(ctl_table *ctl, int write, struct file *filp, 292 + appldata_interval_handler(ctl_table *ctl, int write, 292 293 void __user *buffer, size_t *lenp, loff_t *ppos) 293 294 { 294 295 int len, interval; ··· 334 335 * monitoring (0 = not in process, 1 = in process) 335 336 */ 336 337 static int 337 - appldata_generic_handler(ctl_table *ctl, int write, struct file *filp, 338 + appldata_generic_handler(ctl_table *ctl, int write, 338 339 void __user *buffer, size_t *lenp, loff_t *ppos) 339 340 { 340 341 struct appldata_ops *ops = NULL, *tmp_ops;

+2 -2

arch/s390/kernel/debug.c

··· 881 881 * if debug_active is already off 882 882 */ 883 883 static int 884 - s390dbf_procactive(ctl_table *table, int write, struct file *filp, 884 + s390dbf_procactive(ctl_table *table, int write, 885 885 void __user *buffer, size_t *lenp, loff_t *ppos) 886 886 { 887 887 if (!write || debug_stoppable || !debug_active) 888 - return proc_dointvec(table, write, filp, buffer, lenp, ppos); 888 + return proc_dointvec(table, write, buffer, lenp, ppos); 889 889 else 890 890 return 0; 891 891 }

+2 -2

arch/s390/mm/cmm.c

··· 262 262 static struct ctl_table cmm_table[]; 263 263 264 264 static int 265 - cmm_pages_handler(ctl_table *ctl, int write, struct file *filp, 265 + cmm_pages_handler(ctl_table *ctl, int write, 266 266 void __user *buffer, size_t *lenp, loff_t *ppos) 267 267 { 268 268 char buf[16], *p; ··· 303 303 } 304 304 305 305 static int 306 - cmm_timeout_handler(ctl_table *ctl, int write, struct file *filp, 306 + cmm_timeout_handler(ctl_table *ctl, int write, 307 307 void __user *buffer, size_t *lenp, loff_t *ppos) 308 308 { 309 309 char buf[64], *p;

+1 -2

arch/x86/include/asm/nmi.h

··· 40 40 #define NMI_INVALID 3 41 41 42 42 struct ctl_table; 43 - struct file; 44 - extern int proc_nmi_enabled(struct ctl_table *, int , struct file *, 43 + extern int proc_nmi_enabled(struct ctl_table *, int , 45 44 void __user *, size_t *, loff_t *); 46 45 extern int unknown_nmi_panic; 47 46

+2 -2

arch/x86/kernel/apic/nmi.c

··· 508 508 /* 509 509 * proc handler for /proc/sys/kernel/nmi 510 510 */ 511 - int proc_nmi_enabled(struct ctl_table *table, int write, struct file *file, 511 + int proc_nmi_enabled(struct ctl_table *table, int write, 512 512 void __user *buffer, size_t *length, loff_t *ppos) 513 513 { 514 514 int old_state; 515 515 516 516 nmi_watchdog_enabled = (atomic_read(&nmi_active) > 0) ? 1 : 0; 517 517 old_state = nmi_watchdog_enabled; 518 - proc_dointvec(table, write, file, buffer, length, ppos); 518 + proc_dointvec(table, write, buffer, length, ppos); 519 519 if (!!old_state == !!nmi_watchdog_enabled) 520 520 return 0; 521 521

+1 -9

arch/x86/kernel/vsyscall_64.c

··· 228 228 } 229 229 230 230 #ifdef CONFIG_SYSCTL 231 - 232 - static int 233 - vsyscall_sysctl_change(ctl_table *ctl, int write, struct file * filp, 234 - void __user *buffer, size_t *lenp, loff_t *ppos) 235 - { 236 - return proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 237 - } 238 - 239 231 static ctl_table kernel_table2[] = { 240 232 { .procname = "vsyscall64", 241 233 .data = &vsyscall_gtod_data.sysctl_enabled, .maxlen = sizeof(int), 242 234 .mode = 0644, 243 - .proc_handler = vsyscall_sysctl_change }, 235 + .proc_handler = proc_dointvec }, 244 236 {} 245 237 }; 246 238

+4 -4

drivers/cdrom/cdrom.c

··· 3412 3412 return 0; 3413 3413 } 3414 3414 3415 - static int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp, 3415 + static int cdrom_sysctl_info(ctl_table *ctl, int write, 3416 3416 void __user *buffer, size_t *lenp, loff_t *ppos) 3417 3417 { 3418 3418 int pos; ··· 3489 3489 goto done; 3490 3490 doit: 3491 3491 mutex_unlock(&cdrom_mutex); 3492 - return proc_dostring(ctl, write, filp, buffer, lenp, ppos); 3492 + return proc_dostring(ctl, write, buffer, lenp, ppos); 3493 3493 done: 3494 3494 printk(KERN_INFO "cdrom: info buffer too small\n"); 3495 3495 goto doit; ··· 3525 3525 mutex_unlock(&cdrom_mutex); 3526 3526 } 3527 3527 3528 - static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp, 3528 + static int cdrom_sysctl_handler(ctl_table *ctl, int write, 3529 3529 void __user *buffer, size_t *lenp, loff_t *ppos) 3530 3530 { 3531 3531 int ret; 3532 3532 3533 - ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 3533 + ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 3534 3534 3535 3535 if (write) { 3536 3536

+2 -2

drivers/char/random.c

··· 1231 1231 * as an ASCII string in the standard UUID format. If accesses via the 1232 1232 * sysctl system call, it is returned as 16 bytes of binary data. 1233 1233 */ 1234 - static int proc_do_uuid(ctl_table *table, int write, struct file *filp, 1234 + static int proc_do_uuid(ctl_table *table, int write, 1235 1235 void __user *buffer, size_t *lenp, loff_t *ppos) 1236 1236 { 1237 1237 ctl_table fake_table; ··· 1254 1254 fake_table.data = buf; 1255 1255 fake_table.maxlen = sizeof(buf); 1256 1256 1257 - return proc_dostring(&fake_table, write, filp, buffer, lenp, ppos); 1257 + return proc_dostring(&fake_table, write, buffer, lenp, ppos); 1258 1258 } 1259 1259 1260 1260 static int uuid_strategy(ctl_table *table,

+14 -14

drivers/net/wireless/arlan-proc.c

··· 402 402 403 403 static char arlan_drive_info[ARLAN_STR_SIZE] = "A655\n\0"; 404 404 405 - static int arlan_sysctl_info(ctl_table * ctl, int write, struct file *filp, 405 + static int arlan_sysctl_info(ctl_table * ctl, int write, 406 406 void __user *buffer, size_t * lenp, loff_t *ppos) 407 407 { 408 408 int i; ··· 629 629 *lenp = pos; 630 630 631 631 if (!write) 632 - retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos); 632 + retv = proc_dostring(ctl, write, buffer, lenp, ppos); 633 633 else 634 634 { 635 635 *lenp = 0; ··· 639 639 } 640 640 641 641 642 - static int arlan_sysctl_info161719(ctl_table * ctl, int write, struct file *filp, 642 + static int arlan_sysctl_info161719(ctl_table * ctl, int write, 643 643 void __user *buffer, size_t * lenp, loff_t *ppos) 644 644 { 645 645 int i; ··· 669 669 670 670 final: 671 671 *lenp = pos; 672 - retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos); 672 + retv = proc_dostring(ctl, write, buffer, lenp, ppos); 673 673 return retv; 674 674 } 675 675 676 - static int arlan_sysctl_infotxRing(ctl_table * ctl, int write, struct file *filp, 676 + static int arlan_sysctl_infotxRing(ctl_table * ctl, int write, 677 677 void __user *buffer, size_t * lenp, loff_t *ppos) 678 678 { 679 679 int i; ··· 698 698 SARLBNpln(u_char, txBuffer, 0x800); 699 699 final: 700 700 *lenp = pos; 701 - retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos); 701 + retv = proc_dostring(ctl, write, buffer, lenp, ppos); 702 702 return retv; 703 703 } 704 704 705 - static int arlan_sysctl_inforxRing(ctl_table * ctl, int write, struct file *filp, 705 + static int arlan_sysctl_inforxRing(ctl_table * ctl, int write, 706 706 void __user *buffer, size_t * lenp, loff_t *ppos) 707 707 { 708 708 int i; ··· 726 726 SARLBNpln(u_char, rxBuffer, 0x800); 727 727 final: 728 728 *lenp = pos; 729 - retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos); 729 + retv = proc_dostring(ctl, write, buffer, lenp, ppos); 730 730 return retv; 731 731 } 732 732 733 - static int arlan_sysctl_info18(ctl_table * ctl, int write, struct file *filp, 733 + static int arlan_sysctl_info18(ctl_table * ctl, int write, 734 734 void __user *buffer, size_t * lenp, loff_t *ppos) 735 735 { 736 736 int i; ··· 756 756 757 757 final: 758 758 *lenp = pos; 759 - retv = proc_dostring(ctl, write, filp, buffer, lenp, ppos); 759 + retv = proc_dostring(ctl, write, buffer, lenp, ppos); 760 760 return retv; 761 761 } 762 762 ··· 766 766 767 767 static char conf_reset_result[200]; 768 768 769 - static int arlan_configure(ctl_table * ctl, int write, struct file *filp, 769 + static int arlan_configure(ctl_table * ctl, int write, 770 770 void __user *buffer, size_t * lenp, loff_t *ppos) 771 771 { 772 772 int pos = 0; ··· 788 788 return -1; 789 789 790 790 *lenp = pos; 791 - return proc_dostring(ctl, write, filp, buffer, lenp, ppos); 791 + return proc_dostring(ctl, write, buffer, lenp, ppos); 792 792 } 793 793 794 - static int arlan_sysctl_reset(ctl_table * ctl, int write, struct file *filp, 794 + static int arlan_sysctl_reset(ctl_table * ctl, int write, 795 795 void __user *buffer, size_t * lenp, loff_t *ppos) 796 796 { 797 797 int pos = 0; ··· 811 811 } else 812 812 return -1; 813 813 *lenp = pos + 3; 814 - return proc_dostring(ctl, write, filp, buffer, lenp, ppos); 814 + return proc_dostring(ctl, write, buffer, lenp, ppos); 815 815 } 816 816 817 817

+6 -6

drivers/parport/procfs.c

··· 31 31 #define PARPORT_MIN_SPINTIME_VALUE 1 32 32 #define PARPORT_MAX_SPINTIME_VALUE 1000 33 33 34 - static int do_active_device(ctl_table *table, int write, struct file *filp, 34 + static int do_active_device(ctl_table *table, int write, 35 35 void __user *result, size_t *lenp, loff_t *ppos) 36 36 { 37 37 struct parport *port = (struct parport *)table->extra1; ··· 68 68 } 69 69 70 70 #ifdef CONFIG_PARPORT_1284 71 - static int do_autoprobe(ctl_table *table, int write, struct file *filp, 71 + static int do_autoprobe(ctl_table *table, int write, 72 72 void __user *result, size_t *lenp, loff_t *ppos) 73 73 { 74 74 struct parport_device_info *info = table->extra2; ··· 111 111 #endif /* IEEE1284.3 support. */ 112 112 113 113 static int do_hardware_base_addr (ctl_table *table, int write, 114 - struct file *filp, void __user *result, 114 + void __user *result, 115 115 size_t *lenp, loff_t *ppos) 116 116 { 117 117 struct parport *port = (struct parport *)table->extra1; ··· 139 139 } 140 140 141 141 static int do_hardware_irq (ctl_table *table, int write, 142 - struct file *filp, void __user *result, 142 + void __user *result, 143 143 size_t *lenp, loff_t *ppos) 144 144 { 145 145 struct parport *port = (struct parport *)table->extra1; ··· 167 167 } 168 168 169 169 static int do_hardware_dma (ctl_table *table, int write, 170 - struct file *filp, void __user *result, 170 + void __user *result, 171 171 size_t *lenp, loff_t *ppos) 172 172 { 173 173 struct parport *port = (struct parport *)table->extra1; ··· 195 195 } 196 196 197 197 static int do_hardware_modes (ctl_table *table, int write, 198 - struct file *filp, void __user *result, 198 + void __user *result, 199 199 size_t *lenp, loff_t *ppos) 200 200 { 201 201 struct parport *port = (struct parport *)table->extra1;

+1

fs/coda/coda_int.h

··· 2 2 #define _CODA_INT_ 3 3 4 4 struct dentry; 5 + struct file; 5 6 6 7 extern struct file_system_type coda_fs_type; 7 8 extern unsigned long coda_timeout;

+2 -2

fs/drop_caches.c

··· 63 63 } 64 64 65 65 int drop_caches_sysctl_handler(ctl_table *table, int write, 66 - struct file *file, void __user *buffer, size_t *length, loff_t *ppos) 66 + void __user *buffer, size_t *length, loff_t *ppos) 67 67 { 68 - proc_dointvec_minmax(table, write, file, buffer, length, ppos); 68 + proc_dointvec_minmax(table, write, buffer, length, ppos); 69 69 if (write) { 70 70 if (sysctl_drop_caches & 1) 71 71 drop_pagecache();

+3 -3

fs/file_table.c

··· 74 74 * Handle nr_files sysctl 75 75 */ 76 76 #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS) 77 - int proc_nr_files(ctl_table *table, int write, struct file *filp, 77 + int proc_nr_files(ctl_table *table, int write, 78 78 void __user *buffer, size_t *lenp, loff_t *ppos) 79 79 { 80 80 files_stat.nr_files = get_nr_files(); 81 - return proc_dointvec(table, write, filp, buffer, lenp, ppos); 81 + return proc_dointvec(table, write, buffer, lenp, ppos); 82 82 } 83 83 #else 84 - int proc_nr_files(ctl_table *table, int write, struct file *filp, 84 + int proc_nr_files(ctl_table *table, int write, 85 85 void __user *buffer, size_t *lenp, loff_t *ppos) 86 86 { 87 87 return -ENOSYS;

+1 -1

fs/proc/proc_sysctl.c

··· 153 153 154 154 /* careful: calling conventions are nasty here */ 155 155 res = count; 156 - error = table->proc_handler(table, write, filp, buf, &res, ppos); 156 + error = table->proc_handler(table, write, buf, &res, ppos); 157 157 if (!error) 158 158 error = res; 159 159 out:

+1 -2

fs/xfs/linux-2.6/xfs_sysctl.c

··· 26 26 xfs_stats_clear_proc_handler( 27 27 ctl_table *ctl, 28 28 int write, 29 - struct file *filp, 30 29 void __user *buffer, 31 30 size_t *lenp, 32 31 loff_t *ppos) ··· 33 34 int c, ret, *valp = ctl->data; 34 35 __uint32_t vn_active; 35 36 36 - ret = proc_dointvec_minmax(ctl, write, filp, buffer, lenp, ppos); 37 + ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos); 37 38 38 39 if (!ret && write && *valp) { 39 40 printk("XFS Clearing xfsstats\n");

+1 -1

include/linux/fs.h

··· 2467 2467 size_t len, loff_t *ppos); 2468 2468 2469 2469 struct ctl_table; 2470 - int proc_nr_files(struct ctl_table *table, int write, struct file *filp, 2470 + int proc_nr_files(struct ctl_table *table, int write, 2471 2471 void __user *buffer, size_t *lenp, loff_t *ppos); 2472 2472 2473 2473 int __init get_filesystem_list(char *buf);

+2 -2

include/linux/ftrace.h

··· 19 19 extern int ftrace_enabled; 20 20 extern int 21 21 ftrace_enable_sysctl(struct ctl_table *table, int write, 22 - struct file *filp, void __user *buffer, size_t *lenp, 22 + void __user *buffer, size_t *lenp, 23 23 loff_t *ppos); 24 24 25 25 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip); ··· 94 94 extern int stack_tracer_enabled; 95 95 int 96 96 stack_trace_sysctl(struct ctl_table *table, int write, 97 - struct file *file, void __user *buffer, size_t *lenp, 97 + void __user *buffer, size_t *lenp, 98 98 loff_t *ppos); 99 99 #endif 100 100

+3 -3

include/linux/hugetlb.h

··· 20 20 } 21 21 22 22 void reset_vma_resv_huge_pages(struct vm_area_struct *vma); 23 - int hugetlb_sysctl_handler(struct ctl_table *, int, struct file *, void __user *, size_t *, loff_t *); 24 - int hugetlb_overcommit_handler(struct ctl_table *, int, struct file *, void __user *, size_t *, loff_t *); 25 - int hugetlb_treat_movable_handler(struct ctl_table *, int, struct file *, void __user *, size_t *, loff_t *); 23 + int hugetlb_sysctl_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *); 24 + int hugetlb_overcommit_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *); 25 + int hugetlb_treat_movable_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *); 26 26 int copy_hugetlb_page_range(struct mm_struct *, struct mm_struct *, struct vm_area_struct *); 27 27 int follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *, 28 28 struct page **, struct vm_area_struct **,

+1 -1

include/linux/mm.h

··· 1279 1279 #define in_gate_area(task, addr) ({(void)task; in_gate_area_no_task(addr);}) 1280 1280 #endif /* __HAVE_ARCH_GATE_AREA */ 1281 1281 1282 - int drop_caches_sysctl_handler(struct ctl_table *, int, struct file *, 1282 + int drop_caches_sysctl_handler(struct ctl_table *, int, 1283 1283 void __user *, size_t *, loff_t *); 1284 1284 unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask, 1285 1285 unsigned long lru_pages);

+6 -7

include/linux/mmzone.h

··· 755 755 756 756 /* These two functions are used to setup the per zone pages min values */ 757 757 struct ctl_table; 758 - struct file; 759 - int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *, 758 + int min_free_kbytes_sysctl_handler(struct ctl_table *, int, 760 759 void __user *, size_t *, loff_t *); 761 760 extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1]; 762 - int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *, 761 + int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, 763 762 void __user *, size_t *, loff_t *); 764 - int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *, 763 + int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, 765 764 void __user *, size_t *, loff_t *); 766 765 int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int, 767 - struct file *, void __user *, size_t *, loff_t *); 766 + void __user *, size_t *, loff_t *); 768 767 int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int, 769 - struct file *, void __user *, size_t *, loff_t *); 768 + void __user *, size_t *, loff_t *); 770 769 771 770 extern int numa_zonelist_order_handler(struct ctl_table *, int, 772 - struct file *, void __user *, size_t *, loff_t *); 771 + void __user *, size_t *, loff_t *); 773 772 extern char numa_zonelist_order[]; 774 773 #define NUMA_ZONELIST_ORDER_LEN 16 /* string buffer size */ 775 774

+4 -4

include/linux/sched.h

··· 309 309 extern void touch_softlockup_watchdog(void); 310 310 extern void touch_all_softlockup_watchdogs(void); 311 311 extern int proc_dosoftlockup_thresh(struct ctl_table *table, int write, 312 - struct file *filp, void __user *buffer, 312 + void __user *buffer, 313 313 size_t *lenp, loff_t *ppos); 314 314 extern unsigned int softlockup_panic; 315 315 extern int softlockup_thresh; ··· 331 331 extern unsigned long sysctl_hung_task_timeout_secs; 332 332 extern unsigned long sysctl_hung_task_warnings; 333 333 extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, 334 - struct file *filp, void __user *buffer, 334 + void __user *buffer, 335 335 size_t *lenp, loff_t *ppos); 336 336 #endif 337 337 ··· 1906 1906 extern unsigned int sysctl_timer_migration; 1907 1907 1908 1908 int sched_nr_latency_handler(struct ctl_table *table, int write, 1909 - struct file *file, void __user *buffer, size_t *length, 1909 + void __user *buffer, size_t *length, 1910 1910 loff_t *ppos); 1911 1911 #endif 1912 1912 #ifdef CONFIG_SCHED_DEBUG ··· 1924 1924 extern int sysctl_sched_rt_runtime; 1925 1925 1926 1926 int sched_rt_handler(struct ctl_table *table, int write, 1927 - struct file *filp, void __user *buffer, size_t *lenp, 1927 + void __user *buffer, size_t *lenp, 1928 1928 loff_t *ppos); 1929 1929 1930 1930 extern unsigned int sysctl_sched_compat_yield;

+1 -1

include/linux/security.h

··· 133 133 return PAGE_ALIGN(mmap_min_addr); 134 134 return hint; 135 135 } 136 - extern int mmap_min_addr_handler(struct ctl_table *table, int write, struct file *filp, 136 + extern int mmap_min_addr_handler(struct ctl_table *table, int write, 137 137 void __user *buffer, size_t *lenp, loff_t *ppos); 138 138 139 139 #ifdef CONFIG_SECURITY

+1 -1

include/linux/swap.h

··· 245 245 extern void scan_mapping_unevictable_pages(struct address_space *); 246 246 247 247 extern unsigned long scan_unevictable_pages; 248 - extern int scan_unevictable_handler(struct ctl_table *, int, struct file *, 248 + extern int scan_unevictable_handler(struct ctl_table *, int, 249 249 void __user *, size_t *, loff_t *); 250 250 extern int scan_unevictable_register_node(struct node *node); 251 251 extern void scan_unevictable_unregister_node(struct node *node);

+9 -10

include/linux/sysctl.h

··· 29 29 #include <linux/types.h> 30 30 #include <linux/compiler.h> 31 31 32 - struct file; 33 32 struct completion; 34 33 35 34 #define CTL_MAXNAME 10 /* how many path components do we allow in a ··· 976 977 void __user *oldval, size_t __user *oldlenp, 977 978 void __user *newval, size_t newlen); 978 979 979 - typedef int proc_handler (struct ctl_table *ctl, int write, struct file * filp, 980 + typedef int proc_handler (struct ctl_table *ctl, int write, 980 981 void __user *buffer, size_t *lenp, loff_t *ppos); 981 982 982 - extern int proc_dostring(struct ctl_table *, int, struct file *, 983 + extern int proc_dostring(struct ctl_table *, int, 983 984 void __user *, size_t *, loff_t *); 984 - extern int proc_dointvec(struct ctl_table *, int, struct file *, 985 + extern int proc_dointvec(struct ctl_table *, int, 985 986 void __user *, size_t *, loff_t *); 986 - extern int proc_dointvec_minmax(struct ctl_table *, int, struct file *, 987 + extern int proc_dointvec_minmax(struct ctl_table *, int, 987 988 void __user *, size_t *, loff_t *); 988 - extern int proc_dointvec_jiffies(struct ctl_table *, int, struct file *, 989 + extern int proc_dointvec_jiffies(struct ctl_table *, int, 989 990 void __user *, size_t *, loff_t *); 990 - extern int proc_dointvec_userhz_jiffies(struct ctl_table *, int, struct file *, 991 + extern int proc_dointvec_userhz_jiffies(struct ctl_table *, int, 991 992 void __user *, size_t *, loff_t *); 992 - extern int proc_dointvec_ms_jiffies(struct ctl_table *, int, struct file *, 993 + extern int proc_dointvec_ms_jiffies(struct ctl_table *, int, 993 994 void __user *, size_t *, loff_t *); 994 - extern int proc_doulongvec_minmax(struct ctl_table *, int, struct file *, 995 + extern int proc_doulongvec_minmax(struct ctl_table *, int, 995 996 void __user *, size_t *, loff_t *); 996 997 extern int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int, 997 - struct file *, void __user *, size_t *, loff_t *); 998 + void __user *, size_t *, loff_t *); 998 999 999 1000 extern int do_sysctl (int __user *name, int nlen, 1000 1001 void __user *oldval, size_t __user *oldlenp,

+5 -6

include/linux/writeback.h

··· 110 110 extern unsigned long determine_dirtyable_memory(void); 111 111 112 112 extern int dirty_background_ratio_handler(struct ctl_table *table, int write, 113 - struct file *filp, void __user *buffer, size_t *lenp, 113 + void __user *buffer, size_t *lenp, 114 114 loff_t *ppos); 115 115 extern int dirty_background_bytes_handler(struct ctl_table *table, int write, 116 - struct file *filp, void __user *buffer, size_t *lenp, 116 + void __user *buffer, size_t *lenp, 117 117 loff_t *ppos); 118 118 extern int dirty_ratio_handler(struct ctl_table *table, int write, 119 - struct file *filp, void __user *buffer, size_t *lenp, 119 + void __user *buffer, size_t *lenp, 120 120 loff_t *ppos); 121 121 extern int dirty_bytes_handler(struct ctl_table *table, int write, 122 - struct file *filp, void __user *buffer, size_t *lenp, 122 + void __user *buffer, size_t *lenp, 123 123 loff_t *ppos); 124 124 125 125 struct ctl_table; 126 - struct file; 127 - int dirty_writeback_centisecs_handler(struct ctl_table *, int, struct file *, 126 + int dirty_writeback_centisecs_handler(struct ctl_table *, int, 128 127 void __user *, size_t *, loff_t *); 129 128 130 129 void get_dirty_limits(unsigned long *pbackground, unsigned long *pdirty,

+1 -1

include/net/ip.h

··· 399 399 * fed into the routing cache should use these handlers. 400 400 */ 401 401 int ipv4_doint_and_flush(ctl_table *ctl, int write, 402 - struct file* filp, void __user *buffer, 402 + void __user *buffer, 403 403 size_t *lenp, loff_t *ppos); 404 404 int ipv4_doint_and_flush_strategy(ctl_table *table, 405 405 void __user *oldval, size_t __user *oldlenp,

-2

include/net/ndisc.h

··· 55 55 #include <net/neighbour.h> 56 56 57 57 struct ctl_table; 58 - struct file; 59 58 struct inet6_dev; 60 59 struct net_device; 61 60 struct net_proto_family; ··· 138 139 #ifdef CONFIG_SYSCTL 139 140 extern int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, 140 141 int write, 141 - struct file * filp, 142 142 void __user *buffer, 143 143 size_t *lenp, 144 144 loff_t *ppos);

+8 -8

ipc/ipc_sysctl.c

··· 27 27 } 28 28 29 29 #ifdef CONFIG_PROC_SYSCTL 30 - static int proc_ipc_dointvec(ctl_table *table, int write, struct file *filp, 30 + static int proc_ipc_dointvec(ctl_table *table, int write, 31 31 void __user *buffer, size_t *lenp, loff_t *ppos) 32 32 { 33 33 struct ctl_table ipc_table; 34 34 memcpy(&ipc_table, table, sizeof(ipc_table)); 35 35 ipc_table.data = get_ipc(table); 36 36 37 - return proc_dointvec(&ipc_table, write, filp, buffer, lenp, ppos); 37 + return proc_dointvec(&ipc_table, write, buffer, lenp, ppos); 38 38 } 39 39 40 40 static int proc_ipc_callback_dointvec(ctl_table *table, int write, 41 - struct file *filp, void __user *buffer, size_t *lenp, loff_t *ppos) 41 + void __user *buffer, size_t *lenp, loff_t *ppos) 42 42 { 43 43 struct ctl_table ipc_table; 44 44 size_t lenp_bef = *lenp; ··· 47 47 memcpy(&ipc_table, table, sizeof(ipc_table)); 48 48 ipc_table.data = get_ipc(table); 49 49 50 - rc = proc_dointvec(&ipc_table, write, filp, buffer, lenp, ppos); 50 + rc = proc_dointvec(&ipc_table, write, buffer, lenp, ppos); 51 51 52 52 if (write && !rc && lenp_bef == *lenp) 53 53 /* ··· 61 61 } 62 62 63 63 static int proc_ipc_doulongvec_minmax(ctl_table *table, int write, 64 - struct file *filp, void __user *buffer, size_t *lenp, loff_t *ppos) 64 + void __user *buffer, size_t *lenp, loff_t *ppos) 65 65 { 66 66 struct ctl_table ipc_table; 67 67 memcpy(&ipc_table, table, sizeof(ipc_table)); 68 68 ipc_table.data = get_ipc(table); 69 69 70 - return proc_doulongvec_minmax(&ipc_table, write, filp, buffer, 70 + return proc_doulongvec_minmax(&ipc_table, write, buffer, 71 71 lenp, ppos); 72 72 } 73 73 ··· 95 95 } 96 96 97 97 static int proc_ipcauto_dointvec_minmax(ctl_table *table, int write, 98 - struct file *filp, void __user *buffer, size_t *lenp, loff_t *ppos) 98 + void __user *buffer, size_t *lenp, loff_t *ppos) 99 99 { 100 100 struct ctl_table ipc_table; 101 101 size_t lenp_bef = *lenp; ··· 106 106 ipc_table.data = get_ipc(table); 107 107 oldval = *((int *)(ipc_table.data)); 108 108 109 - rc = proc_dointvec_minmax(&ipc_table, write, filp, buffer, lenp, ppos); 109 + rc = proc_dointvec_minmax(&ipc_table, write, buffer, lenp, ppos); 110 110 111 111 if (write && !rc && lenp_bef == *lenp) { 112 112 int newval = *((int *)(ipc_table.data));

+4 -4

ipc/mq_sysctl.c

··· 31 31 return which; 32 32 } 33 33 34 - static int proc_mq_dointvec(ctl_table *table, int write, struct file *filp, 34 + static int proc_mq_dointvec(ctl_table *table, int write, 35 35 void __user *buffer, size_t *lenp, loff_t *ppos) 36 36 { 37 37 struct ctl_table mq_table; 38 38 memcpy(&mq_table, table, sizeof(mq_table)); 39 39 mq_table.data = get_mq(table); 40 40 41 - return proc_dointvec(&mq_table, write, filp, buffer, lenp, ppos); 41 + return proc_dointvec(&mq_table, write, buffer, lenp, ppos); 42 42 } 43 43 44 44 static int proc_mq_dointvec_minmax(ctl_table *table, int write, 45 - struct file *filp, void __user *buffer, size_t *lenp, loff_t *ppos) 45 + void __user *buffer, size_t *lenp, loff_t *ppos) 46 46 { 47 47 struct ctl_table mq_table; 48 48 memcpy(&mq_table, table, sizeof(mq_table)); 49 49 mq_table.data = get_mq(table); 50 50 51 - return proc_dointvec_minmax(&mq_table, write, filp, buffer, 51 + return proc_dointvec_minmax(&mq_table, write, buffer, 52 52 lenp, ppos); 53 53 } 54 54 #else

+2 -2

kernel/hung_task.c

··· 171 171 * Process updating of timeout sysctl 172 172 */ 173 173 int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, 174 - struct file *filp, void __user *buffer, 174 + void __user *buffer, 175 175 size_t *lenp, loff_t *ppos) 176 176 { 177 177 int ret; 178 178 179 - ret = proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos); 179 + ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos); 180 180 181 181 if (ret || !write) 182 182 goto out;

+2 -2

kernel/sched.c

··· 10312 10312 #endif /* CONFIG_RT_GROUP_SCHED */ 10313 10313 10314 10314 int sched_rt_handler(struct ctl_table *table, int write, 10315 - struct file *filp, void __user *buffer, size_t *lenp, 10315 + void __user *buffer, size_t *lenp, 10316 10316 loff_t *ppos) 10317 10317 { 10318 10318 int ret; ··· 10323 10323 old_period = sysctl_sched_rt_period; 10324 10324 old_runtime = sysctl_sched_rt_runtime; 10325 10325 10326 - ret = proc_dointvec(table, write, filp, buffer, lenp, ppos); 10326 + ret = proc_dointvec(table, write, buffer, lenp, ppos); 10327 10327 10328 10328 if (!ret && write) { 10329 10329 ret = sched_rt_global_constraints();

+2 -2

kernel/sched_fair.c

··· 384 384 385 385 #ifdef CONFIG_SCHED_DEBUG 386 386 int sched_nr_latency_handler(struct ctl_table *table, int write, 387 - struct file *filp, void __user *buffer, size_t *lenp, 387 + void __user *buffer, size_t *lenp, 388 388 loff_t *ppos) 389 389 { 390 - int ret = proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos); 390 + int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 391 391 392 392 if (ret || !write) 393 393 return ret;

+6 -6

kernel/slow-work.c

··· 26 26 static void slow_work_oom_timeout(unsigned long); 27 27 28 28 #ifdef CONFIG_SYSCTL 29 - static int slow_work_min_threads_sysctl(struct ctl_table *, int, struct file *, 29 + static int slow_work_min_threads_sysctl(struct ctl_table *, int, 30 30 void __user *, size_t *, loff_t *); 31 31 32 - static int slow_work_max_threads_sysctl(struct ctl_table *, int , struct file *, 32 + static int slow_work_max_threads_sysctl(struct ctl_table *, int , 33 33 void __user *, size_t *, loff_t *); 34 34 #endif 35 35 ··· 493 493 * Handle adjustment of the minimum number of threads 494 494 */ 495 495 static int slow_work_min_threads_sysctl(struct ctl_table *table, int write, 496 - struct file *filp, void __user *buffer, 496 + void __user *buffer, 497 497 size_t *lenp, loff_t *ppos) 498 498 { 499 - int ret = proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos); 499 + int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 500 500 int n; 501 501 502 502 if (ret == 0) { ··· 521 521 * Handle adjustment of the maximum number of threads 522 522 */ 523 523 static int slow_work_max_threads_sysctl(struct ctl_table *table, int write, 524 - struct file *filp, void __user *buffer, 524 + void __user *buffer, 525 525 size_t *lenp, loff_t *ppos) 526 526 { 527 - int ret = proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos); 527 + int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 528 528 int n; 529 529 530 530 if (ret == 0) {

+2 -2

kernel/softlockup.c

··· 90 90 EXPORT_SYMBOL(touch_all_softlockup_watchdogs); 91 91 92 92 int proc_dosoftlockup_thresh(struct ctl_table *table, int write, 93 - struct file *filp, void __user *buffer, 93 + void __user *buffer, 94 94 size_t *lenp, loff_t *ppos) 95 95 { 96 96 touch_all_softlockup_watchdogs(); 97 - return proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos); 97 + return proc_dointvec_minmax(table, write, buffer, lenp, ppos); 98 98 } 99 99 100 100 /*

+33 -45

kernel/sysctl.c

··· 163 163 #endif 164 164 165 165 #ifdef CONFIG_PROC_SYSCTL 166 - static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp, 166 + static int proc_do_cad_pid(struct ctl_table *table, int write, 167 167 void __user *buffer, size_t *lenp, loff_t *ppos); 168 - static int proc_taint(struct ctl_table *table, int write, struct file *filp, 168 + static int proc_taint(struct ctl_table *table, int write, 169 169 void __user *buffer, size_t *lenp, loff_t *ppos); 170 170 #endif 171 171 ··· 2226 2226 #ifdef CONFIG_PROC_SYSCTL 2227 2227 2228 2228 static int _proc_do_string(void* data, int maxlen, int write, 2229 - struct file *filp, void __user *buffer, 2229 + void __user *buffer, 2230 2230 size_t *lenp, loff_t *ppos) 2231 2231 { 2232 2232 size_t len; ··· 2287 2287 * proc_dostring - read a string sysctl 2288 2288 * @table: the sysctl table 2289 2289 * @write: %TRUE if this is a write to the sysctl file 2290 - * @filp: the file structure 2291 2290 * @buffer: the user buffer 2292 2291 * @lenp: the size of the user buffer 2293 2292 * @ppos: file position ··· 2300 2301 * 2301 2302 * Returns 0 on success. 2302 2303 */ 2303 - int proc_dostring(struct ctl_table *table, int write, struct file *filp, 2304 + int proc_dostring(struct ctl_table *table, int write, 2304 2305 void __user *buffer, size_t *lenp, loff_t *ppos) 2305 2306 { 2306 - return _proc_do_string(table->data, table->maxlen, write, filp, 2307 + return _proc_do_string(table->data, table->maxlen, write, 2307 2308 buffer, lenp, ppos); 2308 2309 } 2309 2310 ··· 2328 2329 } 2329 2330 2330 2331 static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table, 2331 - int write, struct file *filp, void __user *buffer, 2332 + int write, void __user *buffer, 2332 2333 size_t *lenp, loff_t *ppos, 2333 2334 int (*conv)(int *negp, unsigned long *lvalp, int *valp, 2334 2335 int write, void *data), ··· 2435 2436 #undef TMPBUFLEN 2436 2437 } 2437 2438 2438 - static int do_proc_dointvec(struct ctl_table *table, int write, struct file *filp, 2439 + static int do_proc_dointvec(struct ctl_table *table, int write, 2439 2440 void __user *buffer, size_t *lenp, loff_t *ppos, 2440 2441 int (*conv)(int *negp, unsigned long *lvalp, int *valp, 2441 2442 int write, void *data), 2442 2443 void *data) 2443 2444 { 2444 - return __do_proc_dointvec(table->data, table, write, filp, 2445 + return __do_proc_dointvec(table->data, table, write, 2445 2446 buffer, lenp, ppos, conv, data); 2446 2447 } 2447 2448 ··· 2449 2450 * proc_dointvec - read a vector of integers 2450 2451 * @table: the sysctl table 2451 2452 * @write: %TRUE if this is a write to the sysctl file 2452 - * @filp: the file structure 2453 2453 * @buffer: the user buffer 2454 2454 * @lenp: the size of the user buffer 2455 2455 * @ppos: file position ··· 2458 2460 * 2459 2461 * Returns 0 on success. 2460 2462 */ 2461 - int proc_dointvec(struct ctl_table *table, int write, struct file *filp, 2463 + int proc_dointvec(struct ctl_table *table, int write, 2462 2464 void __user *buffer, size_t *lenp, loff_t *ppos) 2463 2465 { 2464 - return do_proc_dointvec(table,write,filp,buffer,lenp,ppos, 2466 + return do_proc_dointvec(table,write,buffer,lenp,ppos, 2465 2467 NULL,NULL); 2466 2468 } 2467 2469 ··· 2469 2471 * Taint values can only be increased 2470 2472 * This means we can safely use a temporary. 2471 2473 */ 2472 - static int proc_taint(struct ctl_table *table, int write, struct file *filp, 2474 + static int proc_taint(struct ctl_table *table, int write, 2473 2475 void __user *buffer, size_t *lenp, loff_t *ppos) 2474 2476 { 2475 2477 struct ctl_table t; ··· 2481 2483 2482 2484 t = *table; 2483 2485 t.data = &tmptaint; 2484 - err = proc_doulongvec_minmax(&t, write, filp, buffer, lenp, ppos); 2486 + err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos); 2485 2487 if (err < 0) 2486 2488 return err; 2487 2489 ··· 2533 2535 * proc_dointvec_minmax - read a vector of integers with min/max values 2534 2536 * @table: the sysctl table 2535 2537 * @write: %TRUE if this is a write to the sysctl file 2536 - * @filp: the file structure 2537 2538 * @buffer: the user buffer 2538 2539 * @lenp: the size of the user buffer 2539 2540 * @ppos: file position ··· 2545 2548 * 2546 2549 * Returns 0 on success. 2547 2550 */ 2548 - int proc_dointvec_minmax(struct ctl_table *table, int write, struct file *filp, 2551 + int proc_dointvec_minmax(struct ctl_table *table, int write, 2549 2552 void __user *buffer, size_t *lenp, loff_t *ppos) 2550 2553 { 2551 2554 struct do_proc_dointvec_minmax_conv_param param = { 2552 2555 .min = (int *) table->extra1, 2553 2556 .max = (int *) table->extra2, 2554 2557 }; 2555 - return do_proc_dointvec(table, write, filp, buffer, lenp, ppos, 2558 + return do_proc_dointvec(table, write, buffer, lenp, ppos, 2556 2559 do_proc_dointvec_minmax_conv, &param); 2557 2560 } 2558 2561 2559 2562 static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write, 2560 - struct file *filp, 2561 2563 void __user *buffer, 2562 2564 size_t *lenp, loff_t *ppos, 2563 2565 unsigned long convmul, ··· 2661 2665 } 2662 2666 2663 2667 static int do_proc_doulongvec_minmax(struct ctl_table *table, int write, 2664 - struct file *filp, 2665 2668 void __user *buffer, 2666 2669 size_t *lenp, loff_t *ppos, 2667 2670 unsigned long convmul, 2668 2671 unsigned long convdiv) 2669 2672 { 2670 2673 return __do_proc_doulongvec_minmax(table->data, table, write, 2671 - filp, buffer, lenp, ppos, convmul, convdiv); 2674 + buffer, lenp, ppos, convmul, convdiv); 2672 2675 } 2673 2676 2674 2677 /** 2675 2678 * proc_doulongvec_minmax - read a vector of long integers with min/max values 2676 2679 * @table: the sysctl table 2677 2680 * @write: %TRUE if this is a write to the sysctl file 2678 - * @filp: the file structure 2679 2681 * @buffer: the user buffer 2680 2682 * @lenp: the size of the user buffer 2681 2683 * @ppos: file position ··· 2686 2692 * 2687 2693 * Returns 0 on success. 2688 2694 */ 2689 - int proc_doulongvec_minmax(struct ctl_table *table, int write, struct file *filp, 2695 + int proc_doulongvec_minmax(struct ctl_table *table, int write, 2690 2696 void __user *buffer, size_t *lenp, loff_t *ppos) 2691 2697 { 2692 - return do_proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos, 1l, 1l); 2698 + return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l); 2693 2699 } 2694 2700 2695 2701 /** 2696 2702 * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values 2697 2703 * @table: the sysctl table 2698 2704 * @write: %TRUE if this is a write to the sysctl file 2699 - * @filp: the file structure 2700 2705 * @buffer: the user buffer 2701 2706 * @lenp: the size of the user buffer 2702 2707 * @ppos: file position ··· 2710 2717 * Returns 0 on success. 2711 2718 */ 2712 2719 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, 2713 - struct file *filp, 2714 2720 void __user *buffer, 2715 2721 size_t *lenp, loff_t *ppos) 2716 2722 { 2717 - return do_proc_doulongvec_minmax(table, write, filp, buffer, 2723 + return do_proc_doulongvec_minmax(table, write, buffer, 2718 2724 lenp, ppos, HZ, 1000l); 2719 2725 } 2720 2726 ··· 2789 2797 * proc_dointvec_jiffies - read a vector of integers as seconds 2790 2798 * @table: the sysctl table 2791 2799 * @write: %TRUE if this is a write to the sysctl file 2792 - * @filp: the file structure 2793 2800 * @buffer: the user buffer 2794 2801 * @lenp: the size of the user buffer 2795 2802 * @ppos: file position ··· 2800 2809 * 2801 2810 * Returns 0 on success. 2802 2811 */ 2803 - int proc_dointvec_jiffies(struct ctl_table *table, int write, struct file *filp, 2812 + int proc_dointvec_jiffies(struct ctl_table *table, int write, 2804 2813 void __user *buffer, size_t *lenp, loff_t *ppos) 2805 2814 { 2806 - return do_proc_dointvec(table,write,filp,buffer,lenp,ppos, 2815 + return do_proc_dointvec(table,write,buffer,lenp,ppos, 2807 2816 do_proc_dointvec_jiffies_conv,NULL); 2808 2817 } 2809 2818 ··· 2811 2820 * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds 2812 2821 * @table: the sysctl table 2813 2822 * @write: %TRUE if this is a write to the sysctl file 2814 - * @filp: the file structure 2815 2823 * @buffer: the user buffer 2816 2824 * @lenp: the size of the user buffer 2817 2825 * @ppos: pointer to the file position ··· 2822 2832 * 2823 2833 * Returns 0 on success. 2824 2834 */ 2825 - int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, struct file *filp, 2835 + int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 2826 2836 void __user *buffer, size_t *lenp, loff_t *ppos) 2827 2837 { 2828 - return do_proc_dointvec(table,write,filp,buffer,lenp,ppos, 2838 + return do_proc_dointvec(table,write,buffer,lenp,ppos, 2829 2839 do_proc_dointvec_userhz_jiffies_conv,NULL); 2830 2840 } 2831 2841 ··· 2833 2843 * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds 2834 2844 * @table: the sysctl table 2835 2845 * @write: %TRUE if this is a write to the sysctl file 2836 - * @filp: the file structure 2837 2846 * @buffer: the user buffer 2838 2847 * @lenp: the size of the user buffer 2839 2848 * @ppos: file position ··· 2845 2856 * 2846 2857 * Returns 0 on success. 2847 2858 */ 2848 - int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, struct file *filp, 2859 + int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, 2849 2860 void __user *buffer, size_t *lenp, loff_t *ppos) 2850 2861 { 2851 - return do_proc_dointvec(table, write, filp, buffer, lenp, ppos, 2862 + return do_proc_dointvec(table, write, buffer, lenp, ppos, 2852 2863 do_proc_dointvec_ms_jiffies_conv, NULL); 2853 2864 } 2854 2865 2855 - static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp, 2866 + static int proc_do_cad_pid(struct ctl_table *table, int write, 2856 2867 void __user *buffer, size_t *lenp, loff_t *ppos) 2857 2868 { 2858 2869 struct pid *new_pid; ··· 2861 2872 2862 2873 tmp = pid_vnr(cad_pid); 2863 2874 2864 - r = __do_proc_dointvec(&tmp, table, write, filp, buffer, 2875 + r = __do_proc_dointvec(&tmp, table, write, buffer, 2865 2876 lenp, ppos, NULL, NULL); 2866 2877 if (r || !write) 2867 2878 return r; ··· 2876 2887 2877 2888 #else /* CONFIG_PROC_FS */ 2878 2889 2879 - int proc_dostring(struct ctl_table *table, int write, struct file *filp, 2890 + int proc_dostring(struct ctl_table *table, int write, 2880 2891 void __user *buffer, size_t *lenp, loff_t *ppos) 2881 2892 { 2882 2893 return -ENOSYS; 2883 2894 } 2884 2895 2885 - int proc_dointvec(struct ctl_table *table, int write, struct file *filp, 2896 + int proc_dointvec(struct ctl_table *table, int write, 2886 2897 void __user *buffer, size_t *lenp, loff_t *ppos) 2887 2898 { 2888 2899 return -ENOSYS; 2889 2900 } 2890 2901 2891 - int proc_dointvec_minmax(struct ctl_table *table, int write, struct file *filp, 2902 + int proc_dointvec_minmax(struct ctl_table *table, int write, 2892 2903 void __user *buffer, size_t *lenp, loff_t *ppos) 2893 2904 { 2894 2905 return -ENOSYS; 2895 2906 } 2896 2907 2897 - int proc_dointvec_jiffies(struct ctl_table *table, int write, struct file *filp, 2908 + int proc_dointvec_jiffies(struct ctl_table *table, int write, 2898 2909 void __user *buffer, size_t *lenp, loff_t *ppos) 2899 2910 { 2900 2911 return -ENOSYS; 2901 2912 } 2902 2913 2903 - int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, struct file *filp, 2914 + int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 2904 2915 void __user *buffer, size_t *lenp, loff_t *ppos) 2905 2916 { 2906 2917 return -ENOSYS; 2907 2918 } 2908 2919 2909 - int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, struct file *filp, 2920 + int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, 2910 2921 void __user *buffer, size_t *lenp, loff_t *ppos) 2911 2922 { 2912 2923 return -ENOSYS; 2913 2924 } 2914 2925 2915 - int proc_doulongvec_minmax(struct ctl_table *table, int write, struct file *filp, 2926 + int proc_doulongvec_minmax(struct ctl_table *table, int write, 2916 2927 void __user *buffer, size_t *lenp, loff_t *ppos) 2917 2928 { 2918 2929 return -ENOSYS; 2919 2930 } 2920 2931 2921 2932 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, 2922 - struct file *filp, 2923 2933 void __user *buffer, 2924 2934 size_t *lenp, loff_t *ppos) 2925 2935 {

+2 -2

kernel/trace/ftrace.c

··· 3015 3015 3016 3016 int 3017 3017 ftrace_enable_sysctl(struct ctl_table *table, int write, 3018 - struct file *file, void __user *buffer, size_t *lenp, 3018 + void __user *buffer, size_t *lenp, 3019 3019 loff_t *ppos) 3020 3020 { 3021 3021 int ret; ··· 3025 3025 3026 3026 mutex_lock(&ftrace_lock); 3027 3027 3028 - ret = proc_dointvec(table, write, file, buffer, lenp, ppos); 3028 + ret = proc_dointvec(table, write, buffer, lenp, ppos); 3029 3029 3030 3030 if (ret || !write || (last_ftrace_enabled == !!ftrace_enabled)) 3031 3031 goto out;

+2 -2

kernel/trace/trace_stack.c

··· 296 296 297 297 int 298 298 stack_trace_sysctl(struct ctl_table *table, int write, 299 - struct file *file, void __user *buffer, size_t *lenp, 299 + void __user *buffer, size_t *lenp, 300 300 loff_t *ppos) 301 301 { 302 302 int ret; 303 303 304 304 mutex_lock(&stack_sysctl_mutex); 305 305 306 - ret = proc_dointvec(table, write, file, buffer, lenp, ppos); 306 + ret = proc_dointvec(table, write, buffer, lenp, ppos); 307 307 308 308 if (ret || !write || 309 309 (last_stack_tracer_enabled == !!stack_tracer_enabled))

+2 -2

kernel/utsname_sysctl.c

··· 42 42 * Special case of dostring for the UTS structure. This has locks 43 43 * to observe. Should this be in kernel/sys.c ???? 44 44 */ 45 - static int proc_do_uts_string(ctl_table *table, int write, struct file *filp, 45 + static int proc_do_uts_string(ctl_table *table, int write, 46 46 void __user *buffer, size_t *lenp, loff_t *ppos) 47 47 { 48 48 struct ctl_table uts_table; 49 49 int r; 50 50 memcpy(&uts_table, table, sizeof(uts_table)); 51 51 uts_table.data = get_uts(table, write); 52 - r = proc_dostring(&uts_table,write,filp,buffer,lenp, ppos); 52 + r = proc_dostring(&uts_table,write,buffer,lenp, ppos); 53 53 put_uts(table, write, uts_table.data); 54 54 return r; 55 55 }

+6 -6

mm/hugetlb.c

··· 1537 1537 1538 1538 #ifdef CONFIG_SYSCTL 1539 1539 int hugetlb_sysctl_handler(struct ctl_table *table, int write, 1540 - struct file *file, void __user *buffer, 1540 + void __user *buffer, 1541 1541 size_t *length, loff_t *ppos) 1542 1542 { 1543 1543 struct hstate *h = &default_hstate; ··· 1548 1548 1549 1549 table->data = &tmp; 1550 1550 table->maxlen = sizeof(unsigned long); 1551 - proc_doulongvec_minmax(table, write, file, buffer, length, ppos); 1551 + proc_doulongvec_minmax(table, write, buffer, length, ppos); 1552 1552 1553 1553 if (write) 1554 1554 h->max_huge_pages = set_max_huge_pages(h, tmp); ··· 1557 1557 } 1558 1558 1559 1559 int hugetlb_treat_movable_handler(struct ctl_table *table, int write, 1560 - struct file *file, void __user *buffer, 1560 + void __user *buffer, 1561 1561 size_t *length, loff_t *ppos) 1562 1562 { 1563 - proc_dointvec(table, write, file, buffer, length, ppos); 1563 + proc_dointvec(table, write, buffer, length, ppos); 1564 1564 if (hugepages_treat_as_movable) 1565 1565 htlb_alloc_mask = GFP_HIGHUSER_MOVABLE; 1566 1566 else ··· 1569 1569 } 1570 1570 1571 1571 int hugetlb_overcommit_handler(struct ctl_table *table, int write, 1572 - struct file *file, void __user *buffer, 1572 + void __user *buffer, 1573 1573 size_t *length, loff_t *ppos) 1574 1574 { 1575 1575 struct hstate *h = &default_hstate; ··· 1580 1580 1581 1581 table->data = &tmp; 1582 1582 table->maxlen = sizeof(unsigned long); 1583 - proc_doulongvec_minmax(table, write, file, buffer, length, ppos); 1583 + proc_doulongvec_minmax(table, write, buffer, length, ppos); 1584 1584 1585 1585 if (write) { 1586 1586 spin_lock(&hugetlb_lock);

+10 -10

mm/page-writeback.c

··· 155 155 } 156 156 157 157 int dirty_background_ratio_handler(struct ctl_table *table, int write, 158 - struct file *filp, void __user *buffer, size_t *lenp, 158 + void __user *buffer, size_t *lenp, 159 159 loff_t *ppos) 160 160 { 161 161 int ret; 162 162 163 - ret = proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos); 163 + ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 164 164 if (ret == 0 && write) 165 165 dirty_background_bytes = 0; 166 166 return ret; 167 167 } 168 168 169 169 int dirty_background_bytes_handler(struct ctl_table *table, int write, 170 - struct file *filp, void __user *buffer, size_t *lenp, 170 + void __user *buffer, size_t *lenp, 171 171 loff_t *ppos) 172 172 { 173 173 int ret; 174 174 175 - ret = proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos); 175 + ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos); 176 176 if (ret == 0 && write) 177 177 dirty_background_ratio = 0; 178 178 return ret; 179 179 } 180 180 181 181 int dirty_ratio_handler(struct ctl_table *table, int write, 182 - struct file *filp, void __user *buffer, size_t *lenp, 182 + void __user *buffer, size_t *lenp, 183 183 loff_t *ppos) 184 184 { 185 185 int old_ratio = vm_dirty_ratio; 186 186 int ret; 187 187 188 - ret = proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos); 188 + ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 189 189 if (ret == 0 && write && vm_dirty_ratio != old_ratio) { 190 190 update_completion_period(); 191 191 vm_dirty_bytes = 0; ··· 195 195 196 196 197 197 int dirty_bytes_handler(struct ctl_table *table, int write, 198 - struct file *filp, void __user *buffer, size_t *lenp, 198 + void __user *buffer, size_t *lenp, 199 199 loff_t *ppos) 200 200 { 201 201 unsigned long old_bytes = vm_dirty_bytes; 202 202 int ret; 203 203 204 - ret = proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos); 204 + ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos); 205 205 if (ret == 0 && write && vm_dirty_bytes != old_bytes) { 206 206 update_completion_period(); 207 207 vm_dirty_ratio = 0; ··· 686 686 * sysctl handler for /proc/sys/vm/dirty_writeback_centisecs 687 687 */ 688 688 int dirty_writeback_centisecs_handler(ctl_table *table, int write, 689 - struct file *file, void __user *buffer, size_t *length, loff_t *ppos) 689 + void __user *buffer, size_t *length, loff_t *ppos) 690 690 { 691 - proc_dointvec(table, write, file, buffer, length, ppos); 691 + proc_dointvec(table, write, buffer, length, ppos); 692 692 return 0; 693 693 } 694 694

+12 -12

mm/page_alloc.c

··· 2373 2373 * sysctl handler for numa_zonelist_order 2374 2374 */ 2375 2375 int numa_zonelist_order_handler(ctl_table *table, int write, 2376 - struct file *file, void __user *buffer, size_t *length, 2376 + void __user *buffer, size_t *length, 2377 2377 loff_t *ppos) 2378 2378 { 2379 2379 char saved_string[NUMA_ZONELIST_ORDER_LEN]; ··· 2382 2382 if (write) 2383 2383 strncpy(saved_string, (char*)table->data, 2384 2384 NUMA_ZONELIST_ORDER_LEN); 2385 - ret = proc_dostring(table, write, file, buffer, length, ppos); 2385 + ret = proc_dostring(table, write, buffer, length, ppos); 2386 2386 if (ret) 2387 2387 return ret; 2388 2388 if (write) { ··· 4706 4706 * changes. 4707 4707 */ 4708 4708 int min_free_kbytes_sysctl_handler(ctl_table *table, int write, 4709 - struct file *file, void __user *buffer, size_t *length, loff_t *ppos) 4709 + void __user *buffer, size_t *length, loff_t *ppos) 4710 4710 { 4711 - proc_dointvec(table, write, file, buffer, length, ppos); 4711 + proc_dointvec(table, write, buffer, length, ppos); 4712 4712 if (write) 4713 4713 setup_per_zone_wmarks(); 4714 4714 return 0; ··· 4716 4716 4717 4717 #ifdef CONFIG_NUMA 4718 4718 int sysctl_min_unmapped_ratio_sysctl_handler(ctl_table *table, int write, 4719 - struct file *file, void __user *buffer, size_t *length, loff_t *ppos) 4719 + void __user *buffer, size_t *length, loff_t *ppos) 4720 4720 { 4721 4721 struct zone *zone; 4722 4722 int rc; 4723 4723 4724 - rc = proc_dointvec_minmax(table, write, file, buffer, length, ppos); 4724 + rc = proc_dointvec_minmax(table, write, buffer, length, ppos); 4725 4725 if (rc) 4726 4726 return rc; 4727 4727 ··· 4732 4732 } 4733 4733 4734 4734 int sysctl_min_slab_ratio_sysctl_handler(ctl_table *table, int write, 4735 - struct file *file, void __user *buffer, size_t *length, loff_t *ppos) 4735 + void __user *buffer, size_t *length, loff_t *ppos) 4736 4736 { 4737 4737 struct zone *zone; 4738 4738 int rc; 4739 4739 4740 - rc = proc_dointvec_minmax(table, write, file, buffer, length, ppos); 4740 + rc = proc_dointvec_minmax(table, write, buffer, length, ppos); 4741 4741 if (rc) 4742 4742 return rc; 4743 4743 ··· 4758 4758 * if in function of the boot time zone sizes. 4759 4759 */ 4760 4760 int lowmem_reserve_ratio_sysctl_handler(ctl_table *table, int write, 4761 - struct file *file, void __user *buffer, size_t *length, loff_t *ppos) 4761 + void __user *buffer, size_t *length, loff_t *ppos) 4762 4762 { 4763 - proc_dointvec_minmax(table, write, file, buffer, length, ppos); 4763 + proc_dointvec_minmax(table, write, buffer, length, ppos); 4764 4764 setup_per_zone_lowmem_reserve(); 4765 4765 return 0; 4766 4766 } ··· 4772 4772 */ 4773 4773 4774 4774 int percpu_pagelist_fraction_sysctl_handler(ctl_table *table, int write, 4775 - struct file *file, void __user *buffer, size_t *length, loff_t *ppos) 4775 + void __user *buffer, size_t *length, loff_t *ppos) 4776 4776 { 4777 4777 struct zone *zone; 4778 4778 unsigned int cpu; 4779 4779 int ret; 4780 4780 4781 - ret = proc_dointvec_minmax(table, write, file, buffer, length, ppos); 4781 + ret = proc_dointvec_minmax(table, write, buffer, length, ppos); 4782 4782 if (!write || (ret == -EINVAL)) 4783 4783 return ret; 4784 4784 for_each_populated_zone(zone) {

+2 -2

mm/vmscan.c

··· 2844 2844 unsigned long scan_unevictable_pages; 2845 2845 2846 2846 int scan_unevictable_handler(struct ctl_table *table, int write, 2847 - struct file *file, void __user *buffer, 2847 + void __user *buffer, 2848 2848 size_t *length, loff_t *ppos) 2849 2849 { 2850 - proc_doulongvec_minmax(table, write, file, buffer, length, ppos); 2850 + proc_doulongvec_minmax(table, write, buffer, length, ppos); 2851 2851 2852 2852 if (write && *(unsigned long *)table->data) 2853 2853 scan_all_zones_unevictable_pages();

+2 -2

net/bridge/br_netfilter.c

··· 965 965 966 966 #ifdef CONFIG_SYSCTL 967 967 static 968 - int brnf_sysctl_call_tables(ctl_table * ctl, int write, struct file *filp, 968 + int brnf_sysctl_call_tables(ctl_table * ctl, int write, 969 969 void __user * buffer, size_t * lenp, loff_t * ppos) 970 970 { 971 971 int ret; 972 972 973 - ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 973 + ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 974 974 975 975 if (write && *(int *)(ctl->data)) 976 976 *(int *)(ctl->data) = 1;

+2 -3

net/decnet/dn_dev.c

··· 164 164 static int min_priority[1]; 165 165 static int max_priority[] = { 127 }; /* From DECnet spec */ 166 166 167 - static int dn_forwarding_proc(ctl_table *, int, struct file *, 167 + static int dn_forwarding_proc(ctl_table *, int, 168 168 void __user *, size_t *, loff_t *); 169 169 static int dn_forwarding_sysctl(ctl_table *table, 170 170 void __user *oldval, size_t __user *oldlenp, ··· 274 274 } 275 275 276 276 static int dn_forwarding_proc(ctl_table *table, int write, 277 - struct file *filep, 278 277 void __user *buffer, 279 278 size_t *lenp, loff_t *ppos) 280 279 { ··· 289 290 dn_db = dev->dn_ptr; 290 291 old = dn_db->parms.forwarding; 291 292 292 - err = proc_dointvec(table, write, filep, buffer, lenp, ppos); 293 + err = proc_dointvec(table, write, buffer, lenp, ppos); 293 294 294 295 if ((err >= 0) && write) { 295 296 if (dn_db->parms.forwarding < 0)

-2

net/decnet/sysctl_net_decnet.c

··· 165 165 } 166 166 167 167 static int dn_node_address_handler(ctl_table *table, int write, 168 - struct file *filp, 169 168 void __user *buffer, 170 169 size_t *lenp, loff_t *ppos) 171 170 { ··· 275 276 276 277 277 278 static int dn_def_dev_handler(ctl_table *table, int write, 278 - struct file * filp, 279 279 void __user *buffer, 280 280 size_t *lenp, loff_t *ppos) 281 281 {

+6 -6

net/ipv4/devinet.c

··· 1270 1270 } 1271 1271 1272 1272 static int devinet_conf_proc(ctl_table *ctl, int write, 1273 - struct file *filp, void __user *buffer, 1273 + void __user *buffer, 1274 1274 size_t *lenp, loff_t *ppos) 1275 1275 { 1276 - int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 1276 + int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 1277 1277 1278 1278 if (write) { 1279 1279 struct ipv4_devconf *cnf = ctl->extra1; ··· 1342 1342 } 1343 1343 1344 1344 static int devinet_sysctl_forward(ctl_table *ctl, int write, 1345 - struct file *filp, void __user *buffer, 1345 + void __user *buffer, 1346 1346 size_t *lenp, loff_t *ppos) 1347 1347 { 1348 1348 int *valp = ctl->data; 1349 1349 int val = *valp; 1350 - int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 1350 + int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 1351 1351 1352 1352 if (write && *valp != val) { 1353 1353 struct net *net = ctl->extra2; ··· 1372 1372 } 1373 1373 1374 1374 int ipv4_doint_and_flush(ctl_table *ctl, int write, 1375 - struct file *filp, void __user *buffer, 1375 + void __user *buffer, 1376 1376 size_t *lenp, loff_t *ppos) 1377 1377 { 1378 1378 int *valp = ctl->data; 1379 1379 int val = *valp; 1380 - int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 1380 + int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 1381 1381 struct net *net = ctl->extra2; 1382 1382 1383 1383 if (write && *valp != val)

+3 -4

net/ipv4/route.c

··· 3036 3036 3037 3037 #ifdef CONFIG_SYSCTL 3038 3038 static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write, 3039 - struct file *filp, void __user *buffer, 3039 + void __user *buffer, 3040 3040 size_t *lenp, loff_t *ppos) 3041 3041 { 3042 3042 if (write) { ··· 3046 3046 3047 3047 memcpy(&ctl, __ctl, sizeof(ctl)); 3048 3048 ctl.data = &flush_delay; 3049 - proc_dointvec(&ctl, write, filp, buffer, lenp, ppos); 3049 + proc_dointvec(&ctl, write, buffer, lenp, ppos); 3050 3050 3051 3051 net = (struct net *)__ctl->extra1; 3052 3052 rt_cache_flush(net, flush_delay); ··· 3106 3106 } 3107 3107 3108 3108 static int ipv4_sysctl_rt_secret_interval(ctl_table *ctl, int write, 3109 - struct file *filp, 3110 3109 void __user *buffer, size_t *lenp, 3111 3110 loff_t *ppos) 3112 3111 { 3113 3112 int old = ip_rt_secret_interval; 3114 - int ret = proc_dointvec_jiffies(ctl, write, filp, buffer, lenp, ppos); 3113 + int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos); 3115 3114 3116 3115 rt_secret_reschedule(old); 3117 3116

+8 -8

net/ipv4/sysctl_net_ipv4.c

··· 36 36 } 37 37 38 38 /* Validate changes from /proc interface. */ 39 - static int ipv4_local_port_range(ctl_table *table, int write, struct file *filp, 39 + static int ipv4_local_port_range(ctl_table *table, int write, 40 40 void __user *buffer, 41 41 size_t *lenp, loff_t *ppos) 42 42 { ··· 51 51 }; 52 52 53 53 inet_get_local_port_range(range, range + 1); 54 - ret = proc_dointvec_minmax(&tmp, write, filp, buffer, lenp, ppos); 54 + ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 55 55 56 56 if (write && ret == 0) { 57 57 if (range[1] < range[0]) ··· 91 91 } 92 92 93 93 94 - static int proc_tcp_congestion_control(ctl_table *ctl, int write, struct file * filp, 94 + static int proc_tcp_congestion_control(ctl_table *ctl, int write, 95 95 void __user *buffer, size_t *lenp, loff_t *ppos) 96 96 { 97 97 char val[TCP_CA_NAME_MAX]; ··· 103 103 104 104 tcp_get_default_congestion_control(val); 105 105 106 - ret = proc_dostring(&tbl, write, filp, buffer, lenp, ppos); 106 + ret = proc_dostring(&tbl, write, buffer, lenp, ppos); 107 107 if (write && ret == 0) 108 108 ret = tcp_set_default_congestion_control(val); 109 109 return ret; ··· 129 129 } 130 130 131 131 static int proc_tcp_available_congestion_control(ctl_table *ctl, 132 - int write, struct file * filp, 132 + int write, 133 133 void __user *buffer, size_t *lenp, 134 134 loff_t *ppos) 135 135 { ··· 140 140 if (!tbl.data) 141 141 return -ENOMEM; 142 142 tcp_get_available_congestion_control(tbl.data, TCP_CA_BUF_MAX); 143 - ret = proc_dostring(&tbl, write, filp, buffer, lenp, ppos); 143 + ret = proc_dostring(&tbl, write, buffer, lenp, ppos); 144 144 kfree(tbl.data); 145 145 return ret; 146 146 } 147 147 148 148 static int proc_allowed_congestion_control(ctl_table *ctl, 149 - int write, struct file * filp, 149 + int write, 150 150 void __user *buffer, size_t *lenp, 151 151 loff_t *ppos) 152 152 { ··· 158 158 return -ENOMEM; 159 159 160 160 tcp_get_allowed_congestion_control(tbl.data, tbl.maxlen); 161 - ret = proc_dostring(&tbl, write, filp, buffer, lenp, ppos); 161 + ret = proc_dostring(&tbl, write, buffer, lenp, ppos); 162 162 if (write && ret == 0) 163 163 ret = tcp_set_allowed_congestion_control(tbl.data); 164 164 kfree(tbl.data);

+4 -4

net/ipv6/addrconf.c

··· 3986 3986 #ifdef CONFIG_SYSCTL 3987 3987 3988 3988 static 3989 - int addrconf_sysctl_forward(ctl_table *ctl, int write, struct file * filp, 3989 + int addrconf_sysctl_forward(ctl_table *ctl, int write, 3990 3990 void __user *buffer, size_t *lenp, loff_t *ppos) 3991 3991 { 3992 3992 int *valp = ctl->data; 3993 3993 int val = *valp; 3994 3994 int ret; 3995 3995 3996 - ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 3996 + ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 3997 3997 3998 3998 if (write) 3999 3999 ret = addrconf_fixup_forwarding(ctl, valp, val); ··· 4090 4090 } 4091 4091 4092 4092 static 4093 - int addrconf_sysctl_disable(ctl_table *ctl, int write, struct file * filp, 4093 + int addrconf_sysctl_disable(ctl_table *ctl, int write, 4094 4094 void __user *buffer, size_t *lenp, loff_t *ppos) 4095 4095 { 4096 4096 int *valp = ctl->data; 4097 4097 int val = *valp; 4098 4098 int ret; 4099 4099 4100 - ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 4100 + ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 4101 4101 4102 4102 if (write) 4103 4103 ret = addrconf_disable_ipv6(ctl, valp, val);

+4 -4

net/ipv6/ndisc.c

··· 1735 1735 } 1736 1736 } 1737 1737 1738 - int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos) 1738 + int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos) 1739 1739 { 1740 1740 struct net_device *dev = ctl->extra1; 1741 1741 struct inet6_dev *idev; ··· 1746 1746 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default"); 1747 1747 1748 1748 if (strcmp(ctl->procname, "retrans_time") == 0) 1749 - ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 1749 + ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 1750 1750 1751 1751 else if (strcmp(ctl->procname, "base_reachable_time") == 0) 1752 1752 ret = proc_dointvec_jiffies(ctl, write, 1753 - filp, buffer, lenp, ppos); 1753 + buffer, lenp, ppos); 1754 1754 1755 1755 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) || 1756 1756 (strcmp(ctl->procname, "base_reachable_time_ms") == 0)) 1757 1757 ret = proc_dointvec_ms_jiffies(ctl, write, 1758 - filp, buffer, lenp, ppos); 1758 + buffer, lenp, ppos); 1759 1759 else 1760 1760 ret = -1; 1761 1761

+2 -2

net/ipv6/route.c

··· 2524 2524 #ifdef CONFIG_SYSCTL 2525 2525 2526 2526 static 2527 - int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp, 2527 + int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, 2528 2528 void __user *buffer, size_t *lenp, loff_t *ppos) 2529 2529 { 2530 2530 struct net *net = current->nsproxy->net_ns; 2531 2531 int delay = net->ipv6.sysctl.flush_delay; 2532 2532 if (write) { 2533 - proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 2533 + proc_dointvec(ctl, write, buffer, lenp, ppos); 2534 2534 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net); 2535 2535 return 0; 2536 2536 } else

+4 -4

net/irda/irsysctl.c

··· 73 73 /* For other sysctl, I've no idea of the range. Maybe Dag could help 74 74 * us on that - Jean II */ 75 75 76 - static int do_devname(ctl_table *table, int write, struct file *filp, 76 + static int do_devname(ctl_table *table, int write, 77 77 void __user *buffer, size_t *lenp, loff_t *ppos) 78 78 { 79 79 int ret; 80 80 81 - ret = proc_dostring(table, write, filp, buffer, lenp, ppos); 81 + ret = proc_dostring(table, write, buffer, lenp, ppos); 82 82 if (ret == 0 && write) { 83 83 struct ias_value *val; 84 84 ··· 90 90 } 91 91 92 92 93 - static int do_discovery(ctl_table *table, int write, struct file *filp, 93 + static int do_discovery(ctl_table *table, int write, 94 94 void __user *buffer, size_t *lenp, loff_t *ppos) 95 95 { 96 96 int ret; 97 97 98 - ret = proc_dointvec(table, write, filp, buffer, lenp, ppos); 98 + ret = proc_dointvec(table, write, buffer, lenp, ppos); 99 99 if (ret) 100 100 return ret; 101 101

+4 -4

net/netfilter/ipvs/ip_vs_ctl.c

··· 1496 1496 1497 1497 1498 1498 static int 1499 - proc_do_defense_mode(ctl_table *table, int write, struct file * filp, 1499 + proc_do_defense_mode(ctl_table *table, int write, 1500 1500 void __user *buffer, size_t *lenp, loff_t *ppos) 1501 1501 { 1502 1502 int *valp = table->data; 1503 1503 int val = *valp; 1504 1504 int rc; 1505 1505 1506 - rc = proc_dointvec(table, write, filp, buffer, lenp, ppos); 1506 + rc = proc_dointvec(table, write, buffer, lenp, ppos); 1507 1507 if (write && (*valp != val)) { 1508 1508 if ((*valp < 0) || (*valp > 3)) { 1509 1509 /* Restore the correct value */ ··· 1517 1517 1518 1518 1519 1519 static int 1520 - proc_do_sync_threshold(ctl_table *table, int write, struct file *filp, 1520 + proc_do_sync_threshold(ctl_table *table, int write, 1521 1521 void __user *buffer, size_t *lenp, loff_t *ppos) 1522 1522 { 1523 1523 int *valp = table->data; ··· 1527 1527 /* backup the value first */ 1528 1528 memcpy(val, valp, sizeof(val)); 1529 1529 1530 - rc = proc_dointvec(table, write, filp, buffer, lenp, ppos); 1530 + rc = proc_dointvec(table, write, buffer, lenp, ppos); 1531 1531 if (write && (valp[0] < 0 || valp[1] < 0 || valp[0] >= valp[1])) { 1532 1532 /* Restore the correct value */ 1533 1533 memcpy(valp, val, sizeof(val));

+2 -2

net/netfilter/nf_log.c

··· 226 226 static struct ctl_table nf_log_sysctl_table[NFPROTO_NUMPROTO+1]; 227 227 static struct ctl_table_header *nf_log_dir_header; 228 228 229 - static int nf_log_proc_dostring(ctl_table *table, int write, struct file *filp, 229 + static int nf_log_proc_dostring(ctl_table *table, int write, 230 230 void __user *buffer, size_t *lenp, loff_t *ppos) 231 231 { 232 232 const struct nf_logger *logger; ··· 260 260 table->data = "NONE"; 261 261 else 262 262 table->data = logger->name; 263 - r = proc_dostring(table, write, filp, buffer, lenp, ppos); 263 + r = proc_dostring(table, write, buffer, lenp, ppos); 264 264 mutex_unlock(&nf_log_mutex); 265 265 } 266 266

+2 -2

net/phonet/sysctl.c

··· 56 56 } while (read_seqretry(&local_port_range_lock, seq)); 57 57 } 58 58 59 - static int proc_local_port_range(ctl_table *table, int write, struct file *filp, 59 + static int proc_local_port_range(ctl_table *table, int write, 60 60 void __user *buffer, 61 61 size_t *lenp, loff_t *ppos) 62 62 { ··· 70 70 .extra2 = &local_port_range_max, 71 71 }; 72 72 73 - ret = proc_dointvec_minmax(&tmp, write, filp, buffer, lenp, ppos); 73 + ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 74 74 75 75 if (write && ret == 0) { 76 76 if (range[1] < range[0])

+2 -2

net/sunrpc/sysctl.c

··· 56 56 } 57 57 } 58 58 59 - static int proc_do_xprt(ctl_table *table, int write, struct file *file, 59 + static int proc_do_xprt(ctl_table *table, int write, 60 60 void __user *buffer, size_t *lenp, loff_t *ppos) 61 61 { 62 62 char tmpbuf[256]; ··· 71 71 } 72 72 73 73 static int 74 - proc_dodebug(ctl_table *table, int write, struct file *file, 74 + proc_dodebug(ctl_table *table, int write, 75 75 void __user *buffer, size_t *lenp, loff_t *ppos) 76 76 { 77 77 char tmpbuf[20], c, *s;

+1 -1

net/sunrpc/xprtrdma/svc_rdma.c

··· 80 80 * current value. 81 81 */ 82 82 static int read_reset_stat(ctl_table *table, int write, 83 - struct file *filp, void __user *buffer, size_t *lenp, 83 + void __user *buffer, size_t *lenp, 84 84 loff_t *ppos) 85 85 { 86 86 atomic_t *stat = (atomic_t *)table->data;

+2 -2

security/min_addr.c

··· 28 28 * sysctl handler which just sets dac_mmap_min_addr = the new value and then 29 29 * calls update_mmap_min_addr() so non MAP_FIXED hints get rounded properly 30 30 */ 31 - int mmap_min_addr_handler(struct ctl_table *table, int write, struct file *filp, 31 + int mmap_min_addr_handler(struct ctl_table *table, int write, 32 32 void __user *buffer, size_t *lenp, loff_t *ppos) 33 33 { 34 34 int ret; 35 35 36 - ret = proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos); 36 + ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos); 37 37 38 38 update_mmap_min_addr(); 39 39