tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

proc: use initializer for clearing some buffers

Save LOC by using dark magic of initialisation instead of memset().

Those buffer aren't passed to userspace directly so padding is not
an issue.

Link: https://lkml.kernel.org/r/3821d3a2-6e10-4629-b0d5-9519d828ab72@p183
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

authored by

Alexey Dobriyan and committed by
Andrew Morton 860a2e7f 867046cc

+9 -18
+6 -10
fs/proc/base.c
··· 1153 1153 static ssize_t oom_adj_write(struct file *file, const char __user *buf, 1154 1154 size_t count, loff_t *ppos) 1155 1155 { 1156 - char buffer[PROC_NUMBUF]; 1156 + char buffer[PROC_NUMBUF] = {}; 1157 1157 int oom_adj; 1158 1158 int err; 1159 1159 1160 - memset(buffer, 0, sizeof(buffer)); 1161 1160 if (count > sizeof(buffer) - 1) 1162 1161 count = sizeof(buffer) - 1; 1163 1162 if (copy_from_user(buffer, buf, count)) { ··· 1212 1213 static ssize_t oom_score_adj_write(struct file *file, const char __user *buf, 1213 1214 size_t count, loff_t *ppos) 1214 1215 { 1215 - char buffer[PROC_NUMBUF]; 1216 + char buffer[PROC_NUMBUF] = {}; 1216 1217 int oom_score_adj; 1217 1218 int err; 1218 1219 1219 - memset(buffer, 0, sizeof(buffer)); 1220 1220 if (count > sizeof(buffer) - 1) 1221 1221 count = sizeof(buffer) - 1; 1222 1222 if (copy_from_user(buffer, buf, count)) { ··· 1356 1358 const char __user * buf, size_t count, loff_t *ppos) 1357 1359 { 1358 1360 struct task_struct *task; 1359 - char buffer[PROC_NUMBUF]; 1361 + char buffer[PROC_NUMBUF] = {}; 1360 1362 int make_it_fail; 1361 1363 int rv; 1362 1364 1363 1365 if (!capable(CAP_SYS_RESOURCE)) 1364 1366 return -EPERM; 1365 - memset(buffer, 0, sizeof(buffer)); 1367 + 1366 1368 if (count > sizeof(buffer) - 1) 1367 1369 count = sizeof(buffer) - 1; 1368 1370 if (copy_from_user(buffer, buf, count)) ··· 1507 1509 { 1508 1510 struct inode *inode = file_inode(file); 1509 1511 struct task_struct *p; 1510 - char buffer[PROC_NUMBUF]; 1512 + char buffer[PROC_NUMBUF] = {}; 1511 1513 int nice; 1512 1514 int err; 1513 1515 1514 - memset(buffer, 0, sizeof(buffer)); 1515 1516 if (count > sizeof(buffer) - 1) 1516 1517 count = sizeof(buffer) - 1; 1517 1518 if (copy_from_user(buffer, buf, count)) ··· 1663 1666 { 1664 1667 struct inode *inode = file_inode(file); 1665 1668 struct task_struct *p; 1666 - char buffer[TASK_COMM_LEN]; 1669 + char buffer[TASK_COMM_LEN] = {}; 1667 1670 const size_t maxlen = sizeof(buffer) - 1; 1668 1671 1669 - memset(buffer, 0, sizeof(buffer)); 1670 1672 if (copy_from_user(buffer, buf, count > maxlen ? maxlen : count)) 1671 1673 return -EFAULT; 1672 1674
+3 -8
fs/proc/task_mmu.c
··· 849 849 static int show_smap(struct seq_file *m, void *v) 850 850 { 851 851 struct vm_area_struct *vma = v; 852 - struct mem_size_stats mss; 853 - 854 - memset(&mss, 0, sizeof(mss)); 852 + struct mem_size_stats mss = {}; 855 853 856 854 smap_gather_stats(vma, &mss, 0); 857 855 ··· 875 877 static int show_smaps_rollup(struct seq_file *m, void *v) 876 878 { 877 879 struct proc_maps_private *priv = m->private; 878 - struct mem_size_stats mss; 880 + struct mem_size_stats mss = {}; 879 881 struct mm_struct *mm = priv->mm; 880 882 struct vm_area_struct *vma; 881 883 unsigned long vma_start = 0, last_vma_end = 0; ··· 890 892 ret = -ESRCH; 891 893 goto out_put_task; 892 894 } 893 - 894 - memset(&mss, 0, sizeof(mss)); 895 895 896 896 ret = mmap_read_lock_killable(mm); 897 897 if (ret) ··· 1242 1246 size_t count, loff_t *ppos) 1243 1247 { 1244 1248 struct task_struct *task; 1245 - char buffer[PROC_NUMBUF]; 1249 + char buffer[PROC_NUMBUF] = {}; 1246 1250 struct mm_struct *mm; 1247 1251 struct vm_area_struct *vma; 1248 1252 enum clear_refs_types type; 1249 1253 int itype; 1250 1254 int rv; 1251 1255 1252 - memset(buffer, 0, sizeof(buffer)); 1253 1256 if (count > sizeof(buffer) - 1) 1254 1257 count = sizeof(buffer) - 1; 1255 1258 if (copy_from_user(buffer, buf, count))