sysctl: Replace void pointer with const pointer to ctl_table

+3 -3

fs/pipe.c

··· 1482 1482 1483 1483 #ifdef CONFIG_SYSCTL 1484 1484 static int do_proc_dopipe_max_size_conv(unsigned long *lvalp, 1485 - unsigned int *valp, 1486 - int write, void *data) 1485 + unsigned int *valp, int write, 1486 + const struct ctl_table *table) 1487 1487 { 1488 1488 if (write) { 1489 1489 unsigned int val; ··· 1505 1505 void *buffer, size_t *lenp, loff_t *ppos) 1506 1506 { 1507 1507 return do_proc_douintvec(table, write, buffer, lenp, ppos, 1508 - do_proc_dopipe_max_size_conv, NULL); 1508 + do_proc_dopipe_max_size_conv); 1509 1509 } 1510 1510 1511 1511 static const struct ctl_table fs_pipe_sysctls[] = {

+2 -3

include/linux/sysctl.h

··· 235 235 int do_proc_douintvec(const struct ctl_table *table, int write, 236 236 void *buffer, size_t *lenp, loff_t *ppos, 237 237 int (*conv)(unsigned long *lvalp, 238 - unsigned int *valp, 239 - int write, void *data), 240 - void *data); 238 + unsigned int *valp, int write, 239 + const struct ctl_table *table)); 241 240 242 241 extern int unaligned_enabled; 243 242 extern int no_unaligned_warning;

+66 -114

kernel/sysctl.c

··· 355 355 } 356 356 357 357 static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp, 358 - int *valp, 359 - int write, void *data) 358 + int *valp, int write, 359 + const struct ctl_table *table) 360 360 { 361 361 if (write) { 362 362 if (*negp) { ··· 382 382 } 383 383 384 384 static int do_proc_douintvec_conv(unsigned long *lvalp, 385 - unsigned int *valp, 386 - int write, void *data) 385 + unsigned int *valp, int write, 386 + const struct ctl_table *table) 387 387 { 388 388 if (write) { 389 389 if (*lvalp > UINT_MAX) ··· 402 402 int write, void *buffer, 403 403 size_t *lenp, loff_t *ppos, 404 404 int (*conv)(bool *negp, unsigned long *lvalp, int *valp, 405 - int write, void *data), 406 - void *data) 405 + int write, const struct ctl_table *table)) 407 406 { 408 407 int *i, vleft, first = 1, err = 0; 409 408 size_t left; ··· 443 444 sizeof(proc_wspace_sep), NULL); 444 445 if (err) 445 446 break; 446 - if (conv(&neg, &lval, i, 1, data)) { 447 + if (conv(&neg, &lval, i, 1, table)) { 447 448 err = -EINVAL; 448 449 break; 449 450 } 450 451 } else { 451 - if (conv(&neg, &lval, i, 0, data)) { 452 + if (conv(&neg, &lval, i, 0, table)) { 452 453 err = -EINVAL; 453 454 break; 454 455 } ··· 473 474 static int do_proc_dointvec(const struct ctl_table *table, int write, 474 475 void *buffer, size_t *lenp, loff_t *ppos, 475 476 int (*conv)(bool *negp, unsigned long *lvalp, int *valp, 476 - int write, void *data), 477 - void *data) 477 + int write, const struct ctl_table *table)) 478 478 { 479 479 return __do_proc_dointvec(table->data, table, write, 480 - buffer, lenp, ppos, conv, data); 480 + buffer, lenp, ppos, conv); 481 481 } 482 482 483 483 static int do_proc_douintvec_w(unsigned int *tbl_data, ··· 484 486 void *buffer, 485 487 size_t *lenp, loff_t *ppos, 486 488 int (*conv)(unsigned long *lvalp, 487 - unsigned int *valp, 488 - int write, void *data), 489 - void *data) 489 + unsigned int *valp, int write, 490 + const struct ctl_table *table)) 490 491 { 491 492 unsigned long lval; 492 493 int err = 0; ··· 515 518 goto out_free; 516 519 } 517 520 518 - if (conv(&lval, tbl_data, 1, data)) { 521 + if (conv(&lval, tbl_data, 1, table)) { 519 522 err = -EINVAL; 520 523 goto out_free; 521 524 } ··· 535 538 return err; 536 539 } 537 540 538 - static int do_proc_douintvec_r(unsigned int *tbl_data, void *buffer, 541 + static int do_proc_douintvec_r(unsigned int *tbl_data, 542 + const struct ctl_table *table, void *buffer, 539 543 size_t *lenp, loff_t *ppos, 540 544 int (*conv)(unsigned long *lvalp, 541 - unsigned int *valp, 542 - int write, void *data), 543 - void *data) 545 + unsigned int *valp, int write, 546 + const struct ctl_table *table)) 544 547 { 545 548 unsigned long lval; 546 549 int err = 0; ··· 548 551 549 552 left = *lenp; 550 553 551 - if (conv(&lval, tbl_data, 0, data)) { 554 + if (conv(&lval, tbl_data, 0, table)) { 552 555 err = -EINVAL; 553 556 goto out; 554 557 } ··· 570 573 int write, void *buffer, 571 574 size_t *lenp, loff_t *ppos, 572 575 int (*conv)(unsigned long *lvalp, 573 - unsigned int *valp, 574 - int write, void *data), 575 - void *data) 576 + unsigned int *valp, int write, 577 + const struct ctl_table *table)) 576 578 { 577 579 unsigned int *i, vleft; 578 580 ··· 597 601 598 602 if (write) 599 603 return do_proc_douintvec_w(i, table, buffer, lenp, ppos, 600 - conv, data); 601 - return do_proc_douintvec_r(i, buffer, lenp, ppos, conv, data); 604 + conv); 605 + return do_proc_douintvec_r(i, table, buffer, lenp, ppos, conv); 602 606 } 603 607 604 608 int do_proc_douintvec(const struct ctl_table *table, int write, 605 609 void *buffer, size_t *lenp, loff_t *ppos, 606 610 int (*conv)(unsigned long *lvalp, 607 - unsigned int *valp, 608 - int write, void *data), 609 - void *data) 611 + unsigned int *valp, int write, 612 + const struct ctl_table *table)) 610 613 { 611 - return __do_proc_douintvec(table->data, table, write, 612 - buffer, lenp, ppos, conv, data); 614 + return __do_proc_douintvec(table->data, table, write, buffer, lenp, 615 + ppos, conv); 613 616 } 614 617 615 618 /** ··· 667 672 int proc_dointvec(const struct ctl_table *table, int write, void *buffer, 668 673 size_t *lenp, loff_t *ppos) 669 674 { 670 - return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL); 675 + return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL); 671 676 } 672 677 673 678 /** ··· 687 692 size_t *lenp, loff_t *ppos) 688 693 { 689 694 return do_proc_douintvec(table, write, buffer, lenp, ppos, 690 - do_proc_douintvec_conv, NULL); 695 + do_proc_douintvec_conv); 691 696 } 692 697 693 - /** 694 - * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure 695 - * @min: pointer to minimum allowable value 696 - * @max: pointer to maximum allowable value 697 - * 698 - * The do_proc_dointvec_minmax_conv_param structure provides the 699 - * minimum and maximum values for doing range checking for those sysctl 700 - * parameters that use the proc_dointvec_minmax() handler. 701 - */ 702 - struct do_proc_dointvec_minmax_conv_param { 703 - int *min; 704 - int *max; 705 - }; 706 - 707 698 static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp, 708 - int *valp, 709 - int write, void *data) 699 + int *valp, int write, 700 + const struct ctl_table *table) 710 701 { 711 - int tmp, ret; 712 - struct do_proc_dointvec_minmax_conv_param *param = data; 702 + int tmp, ret, *min, *max; 713 703 /* 714 704 * If writing, first do so via a temporary local int so we can 715 705 * bounds-check it before touching *valp. 716 706 */ 717 707 int *ip = write ? &tmp : valp; 718 708 719 - ret = do_proc_dointvec_conv(negp, lvalp, ip, write, data); 709 + ret = do_proc_dointvec_conv(negp, lvalp, ip, write, table); 720 710 if (ret) 721 711 return ret; 722 712 723 713 if (write) { 724 - if ((param->min && *param->min > tmp) || 725 - (param->max && *param->max < tmp)) 714 + min = (int *) table->extra1; 715 + max = (int *) table->extra2; 716 + if ((min && *min > tmp) || (max && *max < tmp)) 726 717 return -EINVAL; 727 718 WRITE_ONCE(*valp, tmp); 728 719 } ··· 735 754 int proc_dointvec_minmax(const struct ctl_table *table, int write, 736 755 void *buffer, size_t *lenp, loff_t *ppos) 737 756 { 738 - struct do_proc_dointvec_minmax_conv_param param = { 739 - .min = (int *) table->extra1, 740 - .max = (int *) table->extra2, 741 - }; 742 757 return do_proc_dointvec(table, write, buffer, lenp, ppos, 743 - do_proc_dointvec_minmax_conv, &param); 758 + do_proc_dointvec_minmax_conv); 744 759 } 745 760 746 - /** 747 - * struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure 748 - * @min: pointer to minimum allowable value 749 - * @max: pointer to maximum allowable value 750 - * 751 - * The do_proc_douintvec_minmax_conv_param structure provides the 752 - * minimum and maximum values for doing range checking for those sysctl 753 - * parameters that use the proc_douintvec_minmax() handler. 754 - */ 755 - struct do_proc_douintvec_minmax_conv_param { 756 - unsigned int *min; 757 - unsigned int *max; 758 - }; 759 - 760 761 static int do_proc_douintvec_minmax_conv(unsigned long *lvalp, 761 - unsigned int *valp, 762 - int write, void *data) 762 + unsigned int *valp, int write, 763 + const struct ctl_table *table) 763 764 { 764 765 int ret; 765 - unsigned int tmp; 766 - struct do_proc_douintvec_minmax_conv_param *param = data; 766 + unsigned int tmp, *min, *max; 767 767 /* write via temporary local uint for bounds-checking */ 768 768 unsigned int *up = write ? &tmp : valp; 769 769 770 - ret = do_proc_douintvec_conv(lvalp, up, write, data); 770 + ret = do_proc_douintvec_conv(lvalp, up, write, table); 771 771 if (ret) 772 772 return ret; 773 773 774 774 if (write) { 775 - if ((param->min && *param->min > tmp) || 776 - (param->max && *param->max < tmp)) 775 + min = (unsigned int *) table->extra1; 776 + max = (unsigned int *) table->extra2; 777 + if ((min && *min > tmp) || (max && *max < tmp)) 777 778 return -ERANGE; 778 779 779 780 WRITE_ONCE(*valp, tmp); ··· 786 823 int proc_douintvec_minmax(const struct ctl_table *table, int write, 787 824 void *buffer, size_t *lenp, loff_t *ppos) 788 825 { 789 - struct do_proc_douintvec_minmax_conv_param param = { 790 - .min = (unsigned int *) table->extra1, 791 - .max = (unsigned int *) table->extra2, 792 - }; 793 826 return do_proc_douintvec(table, write, buffer, lenp, ppos, 794 - do_proc_douintvec_minmax_conv, &param); 827 + do_proc_douintvec_minmax_conv); 795 828 } 796 829 797 830 /** ··· 813 854 struct ctl_table tmp; 814 855 unsigned int min = 0, max = 255U, val; 815 856 u8 *data = table->data; 816 - struct do_proc_douintvec_minmax_conv_param param = { 817 - .min = &min, 818 - .max = &max, 819 - }; 820 857 int res; 821 858 822 859 /* Do not support arrays yet. */ 823 860 if (table->maxlen != sizeof(u8)) 824 861 return -EINVAL; 825 862 826 - if (table->extra1) 827 - min = *(unsigned int *) table->extra1; 828 - if (table->extra2) 829 - max = *(unsigned int *) table->extra2; 830 - 831 863 tmp = *table; 832 864 833 865 tmp.maxlen = sizeof(val); 834 866 tmp.data = &val; 867 + if (!tmp.extra1) 868 + tmp.extra1 = (unsigned int *) &min; 869 + if (!tmp.extra2) 870 + tmp.extra2 = (unsigned int *) &max; 871 + 835 872 val = READ_ONCE(*data); 836 873 res = do_proc_douintvec(&tmp, write, buffer, lenp, ppos, 837 - do_proc_douintvec_minmax_conv, &param); 874 + do_proc_douintvec_minmax_conv); 838 875 if (res) 839 876 return res; 840 877 if (write) ··· 969 1014 970 1015 971 1016 static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp, 972 - int *valp, 973 - int write, void *data) 1017 + int *valp, int write, 1018 + const struct ctl_table *table) 974 1019 { 975 1020 if (write) { 976 1021 if (*lvalp > INT_MAX / HZ) ··· 995 1040 } 996 1041 997 1042 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp, 998 - int *valp, 999 - int write, void *data) 1043 + int *valp, int write, 1044 + const struct ctl_table *table) 1000 1045 { 1001 1046 if (write) { 1002 1047 if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ) ··· 1018 1063 } 1019 1064 1020 1065 static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp, 1021 - int *valp, 1022 - int write, void *data) 1066 + int *valp, int write, 1067 + const struct ctl_table *table) 1023 1068 { 1024 1069 if (write) { 1025 1070 unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp); ··· 1043 1088 } 1044 1089 1045 1090 static int do_proc_dointvec_ms_jiffies_minmax_conv(bool *negp, unsigned long *lvalp, 1046 - int *valp, int write, void *data) 1091 + int *valp, int write, 1092 + const struct ctl_table *table) 1047 1093 { 1048 - int tmp, ret; 1049 - struct do_proc_dointvec_minmax_conv_param *param = data; 1094 + int tmp, ret, *min, *max; 1050 1095 /* 1051 1096 * If writing, first do so via a temporary local int so we can 1052 1097 * bounds-check it before touching *valp. 1053 1098 */ 1054 1099 int *ip = write ? &tmp : valp; 1055 1100 1056 - ret = do_proc_dointvec_ms_jiffies_conv(negp, lvalp, ip, write, data); 1101 + ret = do_proc_dointvec_ms_jiffies_conv(negp, lvalp, ip, write, table); 1057 1102 if (ret) 1058 1103 return ret; 1059 1104 1060 1105 if (write) { 1061 - if ((param->min && *param->min > tmp) || 1062 - (param->max && *param->max < tmp)) 1106 + min = (int *) table->extra1; 1107 + max = (int *) table->extra2; 1108 + if ((min && *min > tmp) || (max && *max < tmp)) 1063 1109 return -EINVAL; 1064 1110 *valp = tmp; 1065 1111 } ··· 1086 1130 void *buffer, size_t *lenp, loff_t *ppos) 1087 1131 { 1088 1132 return do_proc_dointvec(table,write,buffer,lenp,ppos, 1089 - do_proc_dointvec_jiffies_conv,NULL); 1133 + do_proc_dointvec_jiffies_conv); 1090 1134 } 1091 1135 1092 1136 int proc_dointvec_ms_jiffies_minmax(const struct ctl_table *table, int write, 1093 1137 void *buffer, size_t *lenp, loff_t *ppos) 1094 1138 { 1095 - struct do_proc_dointvec_minmax_conv_param param = { 1096 - .min = (int *) table->extra1, 1097 - .max = (int *) table->extra2, 1098 - }; 1099 1139 return do_proc_dointvec(table, write, buffer, lenp, ppos, 1100 - do_proc_dointvec_ms_jiffies_minmax_conv, &param); 1140 + do_proc_dointvec_ms_jiffies_minmax_conv); 1101 1141 } 1102 1142 1103 1143 /** ··· 1115 1163 void *buffer, size_t *lenp, loff_t *ppos) 1116 1164 { 1117 1165 return do_proc_dointvec(table, write, buffer, lenp, ppos, 1118 - do_proc_dointvec_userhz_jiffies_conv, NULL); 1166 + do_proc_dointvec_userhz_jiffies_conv); 1119 1167 } 1120 1168 1121 1169 /** ··· 1137 1185 size_t *lenp, loff_t *ppos) 1138 1186 { 1139 1187 return do_proc_dointvec(table, write, buffer, lenp, ppos, 1140 - do_proc_dointvec_ms_jiffies_conv, NULL); 1188 + do_proc_dointvec_ms_jiffies_conv); 1141 1189 } 1142 1190 1143 1191 /**

Configure Feed

Configure Feed