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

Configure Feed

Select the types of activity you want to include in your feed.

f2fs: fix out-of-bounds access in sysfs attribute read/write

Some f2fs sysfs attributes suffer from out-of-bounds memory access and
incorrect handling of integer values whose size is not 4 bytes.

For example:
vm:~# echo 65537 > /sys/fs/f2fs/vde/carve_out
vm:~# cat /sys/fs/f2fs/vde/carve_out
65537
vm:~# echo 4294967297 > /sys/fs/f2fs/vde/atgc_age_threshold
vm:~# cat /sys/fs/f2fs/vde/atgc_age_threshold
1

carve_out maps to {struct f2fs_sb_info}->carve_out, which is a 8-bit
integer. However, the sysfs interface allows setting it to a value
larger than 255, resulting in an out-of-range update.

atgc_age_threshold maps to {struct atgc_management}->age_threshold,
which is a 64-bit integer, but its sysfs interface cannot correctly set
values larger than UINT_MAX.

The root causes are:
1. __sbi_store() treats all default values as unsigned int, which
prevents updating integers larger than 4 bytes and causes out-of-bounds
writes for integers smaller than 4 bytes.

2. f2fs_sbi_show() also assumes all default values are unsigned int,
leading to out-of-bounds reads and incorrect access to integers larger
than 4 bytes.

This patch introduces {struct f2fs_attr}->size to record the actual size
of the integer associated with each sysfs attribute. With this
information, sysfs read and write operations can correctly access and
update values according to their real data size, avoiding memory
corruption and truncation.

Fixes: b59d0bae6ca3 ("f2fs: add sysfs support for controlling the gc_thread")
Cc: stable@kernel.org
Signed-off-by: Jinbao Liu <liujinbao1@xiaomi.com>
Signed-off-by: Yongpeng Yang <yangyongpeng@xiaomi.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

authored by

Yongpeng Yang and committed by
Jaegeuk Kim
98ea0039 c0c589fa

+52 -8
+52 -8
fs/f2fs/sysfs.c
··· 59 59 const char *buf, size_t len); 60 60 int struct_type; 61 61 int offset; 62 + int size; 62 63 int id; 63 64 }; 64 65 ··· 346 345 (unsigned long long)MAIN_BLKADDR(sbi)); 347 346 } 348 347 348 + static ssize_t __sbi_show_value(struct f2fs_attr *a, 349 + struct f2fs_sb_info *sbi, char *buf, 350 + unsigned char *value) 351 + { 352 + switch (a->size) { 353 + case 1: 354 + return sysfs_emit(buf, "%u\n", *(u8 *)value); 355 + case 2: 356 + return sysfs_emit(buf, "%u\n", *(u16 *)value); 357 + case 4: 358 + return sysfs_emit(buf, "%u\n", *(u32 *)value); 359 + case 8: 360 + return sysfs_emit(buf, "%llu\n", *(u64 *)value); 361 + default: 362 + f2fs_bug_on(sbi, 1); 363 + return sysfs_emit(buf, 364 + "show sysfs node value with wrong type\n"); 365 + } 366 + } 367 + 349 368 static ssize_t f2fs_sbi_show(struct f2fs_attr *a, 350 369 struct f2fs_sb_info *sbi, char *buf) 351 370 { 352 371 unsigned char *ptr = NULL; 353 - unsigned int *ui; 354 372 355 373 ptr = __struct_ptr(sbi, a->struct_type); 356 374 if (!ptr) ··· 449 429 atomic_read(&sbi->cp_call_count[BACKGROUND])); 450 430 #endif 451 431 452 - ui = (unsigned int *)(ptr + a->offset); 432 + return __sbi_show_value(a, sbi, buf, ptr + a->offset); 433 + } 453 434 454 - return sysfs_emit(buf, "%u\n", *ui); 435 + static void __sbi_store_value(struct f2fs_attr *a, 436 + struct f2fs_sb_info *sbi, 437 + unsigned char *ui, unsigned long value) 438 + { 439 + switch (a->size) { 440 + case 1: 441 + *(u8 *)ui = value; 442 + break; 443 + case 2: 444 + *(u16 *)ui = value; 445 + break; 446 + case 4: 447 + *(u32 *)ui = value; 448 + break; 449 + case 8: 450 + *(u64 *)ui = value; 451 + break; 452 + default: 453 + f2fs_bug_on(sbi, 1); 454 + f2fs_err(sbi, "store sysfs node value with wrong type"); 455 + } 455 456 } 456 457 457 458 static ssize_t __sbi_store(struct f2fs_attr *a, ··· 954 913 return count; 955 914 } 956 915 957 - *ui = (unsigned int)t; 916 + __sbi_store_value(a, sbi, ptr + a->offset, t); 958 917 959 918 return count; 960 919 } ··· 1101 1060 .id = F2FS_FEATURE_##_feat, \ 1102 1061 } 1103 1062 1104 - #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \ 1063 + #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset, _size) \ 1105 1064 static struct f2fs_attr f2fs_attr_##_name = { \ 1106 1065 .attr = {.name = __stringify(_name), .mode = _mode }, \ 1107 1066 .show = _show, \ 1108 1067 .store = _store, \ 1109 1068 .struct_type = _struct_type, \ 1110 - .offset = _offset \ 1069 + .offset = _offset, \ 1070 + .size = _size \ 1111 1071 } 1112 1072 1113 1073 #define F2FS_RO_ATTR(struct_type, struct_name, name, elname) \ 1114 1074 F2FS_ATTR_OFFSET(struct_type, name, 0444, \ 1115 1075 f2fs_sbi_show, NULL, \ 1116 - offsetof(struct struct_name, elname)) 1076 + offsetof(struct struct_name, elname), \ 1077 + sizeof_field(struct struct_name, elname)) 1117 1078 1118 1079 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \ 1119 1080 F2FS_ATTR_OFFSET(struct_type, name, 0644, \ 1120 1081 f2fs_sbi_show, f2fs_sbi_store, \ 1121 - offsetof(struct struct_name, elname)) 1082 + offsetof(struct struct_name, elname), \ 1083 + sizeof_field(struct struct_name, elname)) 1122 1084 1123 1085 #define F2FS_GENERAL_RO_ATTR(name) \ 1124 1086 static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL)