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

sysfs: treewide: switch back to bin_attribute::read()/write()

The bin_attribute argument of bin_attribute::read() is now const.
This makes the _new() callbacks unnecessary. Switch all users back.

Signed-off-by: Thomas Weißschuh <linux@weissschuh.net>
Link: https://lore.kernel.org/r/20250530-sysfs-const-bin_attr-final-v3-3-724bfcf05b99@weissschuh.net
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Thomas Weißschuh and committed by
Greg Kroah-Hartman 2fbe8203 340d8e66

+188 -188
+1 -1
arch/powerpc/platforms/powernv/opal-core.c
··· 208 208 209 209 static struct bin_attribute opal_core_attr __ro_after_init = { 210 210 .attr = {.name = "core", .mode = 0400}, 211 - .read_new = read_opalcore 211 + .read = read_opalcore 212 212 }; 213 213 214 214 /*
+1 -1
arch/powerpc/platforms/powernv/opal-dump.c
··· 342 342 dump->dump_attr.attr.name = "dump"; 343 343 dump->dump_attr.attr.mode = 0400; 344 344 dump->dump_attr.size = size; 345 - dump->dump_attr.read_new = dump_attr_read; 345 + dump->dump_attr.read = dump_attr_read; 346 346 347 347 dump->id = id; 348 348 dump->size = size;
+1 -1
arch/powerpc/platforms/powernv/opal-elog.c
··· 203 203 elog->raw_attr.attr.name = "raw"; 204 204 elog->raw_attr.attr.mode = 0400; 205 205 elog->raw_attr.size = size; 206 - elog->raw_attr.read_new = raw_attr_read; 206 + elog->raw_attr.read = raw_attr_read; 207 207 208 208 elog->id = id; 209 209 elog->size = size;
+1 -1
arch/powerpc/platforms/powernv/opal-flash.c
··· 493 493 static const struct bin_attribute image_data_attr = { 494 494 .attr = {.name = "image", .mode = 0200}, 495 495 .size = MAX_IMAGE_SIZE, /* Limit image size */ 496 - .write_new = image_data_write, 496 + .write = image_data_write, 497 497 }; 498 498 499 499 static struct kobj_attribute validate_attribute =
+1 -1
arch/powerpc/platforms/powernv/opal-msglog.c
··· 102 102 103 103 static struct bin_attribute opal_msglog_attr __ro_after_init = { 104 104 .attr = {.name = "msglog", .mode = 0400}, 105 - .read_new = opal_msglog_read 105 + .read = opal_msglog_read 106 106 }; 107 107 108 108 struct memcons *__init memcons_init(struct device_node *node, const char *mc_prop_name)
+1 -1
arch/powerpc/platforms/powernv/opal.c
··· 815 815 sysfs_bin_attr_init(attr); 816 816 attr->attr.name = name; 817 817 attr->attr.mode = 0400; 818 - attr->read_new = sysfs_bin_attr_simple_read; 818 + attr->read = sysfs_bin_attr_simple_read; 819 819 attr->private = __va(vals[0]); 820 820 attr->size = vals[1]; 821 821
+1 -1
arch/powerpc/platforms/powernv/ultravisor.c
··· 40 40 41 41 static struct bin_attribute uv_msglog_attr __ro_after_init = { 42 42 .attr = {.name = "msglog", .mode = 0400}, 43 - .read_new = uv_msglog_read 43 + .read = uv_msglog_read 44 44 }; 45 45 46 46 static int __init uv_init(void)
+2 -2
arch/x86/kernel/ksysfs.c
··· 40 40 .name = "data", 41 41 .mode = S_IRUGO, 42 42 }, 43 - .read_new = boot_params_data_read, 43 + .read = boot_params_data_read, 44 44 .size = sizeof(boot_params), 45 45 }; 46 46 ··· 250 250 .name = "data", 251 251 .mode = S_IRUGO, 252 252 }, 253 - .read_new = setup_data_data_read, 253 + .read = setup_data_data_read, 254 254 }; 255 255 256 256 static struct attribute *setup_data_type_attrs[] = {
+1 -1
drivers/accel/habanalabs/common/sysfs.c
··· 446 446 static const struct bin_attribute bin_attr_eeprom = { 447 447 .attr = {.name = "eeprom", .mode = (0444)}, 448 448 .size = PAGE_SIZE, 449 - .read_new = eeprom_read_handler 449 + .read = eeprom_read_handler 450 450 }; 451 451 452 452 static struct attribute *hl_dev_attrs[] = {
+2 -2
drivers/acpi/sysfs.c
··· 372 372 } 373 373 374 374 table_attr->attr.size = table_header->length; 375 - table_attr->attr.read_new = acpi_table_show; 375 + table_attr->attr.read = acpi_table_show; 376 376 table_attr->attr.attr.name = table_attr->filename; 377 377 table_attr->attr.attr.mode = 0400; 378 378 ··· 495 495 if (!data_attr) 496 496 return -ENOMEM; 497 497 sysfs_attr_init(&data_attr->attr.attr); 498 - data_attr->attr.read_new = acpi_data_show; 498 + data_attr->attr.read = acpi_data_show; 499 499 data_attr->attr.attr.mode = 0400; 500 500 return acpi_data_objs[i].fn(th, data_attr); 501 501 }
+2 -2
drivers/base/firmware_loader/sysfs.c
··· 359 359 static const struct bin_attribute firmware_attr_data = { 360 360 .attr = { .name = "data", .mode = 0644 }, 361 361 .size = 0, 362 - .read_new = firmware_data_read, 363 - .write_new = firmware_data_write, 362 + .read = firmware_data_read, 363 + .write = firmware_data_write, 364 364 }; 365 365 366 366 static struct attribute *fw_dev_attrs[] = {
+1 -1
drivers/firmware/efi/mokvar-table.c
··· 340 340 mokvar_sysfs->bin_attr.attr.name = mokvar_entry->name; 341 341 mokvar_sysfs->bin_attr.attr.mode = 0400; 342 342 mokvar_sysfs->bin_attr.size = mokvar_entry->data_size; 343 - mokvar_sysfs->bin_attr.read_new = efi_mokvar_sysfs_read; 343 + mokvar_sysfs->bin_attr.read = efi_mokvar_sysfs_read; 344 344 345 345 err = sysfs_create_bin_file(mokvar_kobj, 346 346 &mokvar_sysfs->bin_attr);
+1 -1
drivers/firmware/google/gsmi.c
··· 530 530 531 531 static const struct bin_attribute eventlog_bin_attr = { 532 532 .attr = {.name = "append_to_eventlog", .mode = 0200}, 533 - .write_new = eventlog_write, 533 + .write = eventlog_write, 534 534 }; 535 535 536 536 static ssize_t gsmi_clear_eventlog_store(struct kobject *kobj,
+1 -1
drivers/firmware/google/memconsole.c
··· 28 28 29 29 static struct bin_attribute memconsole_bin_attr = { 30 30 .attr = {.name = "log", .mode = 0444}, 31 - .read_new = memconsole_read, 31 + .read = memconsole_read, 32 32 }; 33 33 34 34 void memconsole_setup(ssize_t (*read_func)(char *, loff_t, size_t))
+2 -2
drivers/firmware/google/vpd.c
··· 121 121 info->bin_attr.attr.name = info->key; 122 122 info->bin_attr.attr.mode = 0444; 123 123 info->bin_attr.size = value_len; 124 - info->bin_attr.read_new = vpd_attrib_read; 124 + info->bin_attr.read = vpd_attrib_read; 125 125 info->bin_attr.private = info; 126 126 127 127 info->value = value; ··· 201 201 sec->bin_attr.attr.name = sec->raw_name; 202 202 sec->bin_attr.attr.mode = 0444; 203 203 sec->bin_attr.size = size; 204 - sec->bin_attr.read_new = vpd_section_read; 204 + sec->bin_attr.read = vpd_section_read; 205 205 sec->bin_attr.private = sec; 206 206 207 207 err = sysfs_create_bin_file(vpd_kobj, &sec->bin_attr);
+1 -1
drivers/firmware/qemu_fw_cfg.c
··· 476 476 477 477 static const struct bin_attribute fw_cfg_sysfs_attr_raw = { 478 478 .attr = { .name = "raw", .mode = S_IRUSR }, 479 - .read_new = fw_cfg_sysfs_read_raw, 479 + .read = fw_cfg_sysfs_read_raw, 480 480 }; 481 481 482 482 /*
+2 -2
drivers/fsi/fsi-core.c
··· 613 613 .mode = 0600, 614 614 }, 615 615 .size = 0, 616 - .read_new = fsi_slave_sysfs_raw_read, 617 - .write_new = fsi_slave_sysfs_raw_write, 616 + .read = fsi_slave_sysfs_raw_read, 617 + .write = fsi_slave_sysfs_raw_write, 618 618 }; 619 619 620 620 static void fsi_slave_release(struct device *dev)
+2 -2
drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c
··· 4117 4117 static const struct bin_attribute psp_vbflash_bin_attr = { 4118 4118 .attr = {.name = "psp_vbflash", .mode = 0660}, 4119 4119 .size = 0, 4120 - .write_new = amdgpu_psp_vbflash_write, 4121 - .read_new = amdgpu_psp_vbflash_read, 4120 + .write = amdgpu_psp_vbflash_write, 4121 + .read = amdgpu_psp_vbflash_read, 4122 4122 }; 4123 4123 4124 4124 /**
+2 -2
drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_hdcp.c
··· 723 723 static const struct bin_attribute data_attr = { 724 724 .attr = {.name = "hdcp_srm", .mode = 0664}, 725 725 .size = PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE, /* Limit SRM size */ 726 - .write_new = srm_data_write, 727 - .read_new = srm_data_read, 726 + .write = srm_data_write, 727 + .read = srm_data_read, 728 728 }; 729 729 730 730 struct hdcp_workqueue *hdcp_create_workqueue(struct amdgpu_device *adev,
+1 -1
drivers/gpu/drm/drm_sysfs.c
··· 319 319 .attr.name = "edid", 320 320 .attr.mode = 0444, 321 321 .size = 0, 322 - .read_new = edid_show, 322 + .read = edid_show, 323 323 }; 324 324 325 325 static const struct bin_attribute *const connector_bin_attrs[] = {
+2 -2
drivers/gpu/drm/i915/i915_gpu_error.c
··· 2506 2506 .attr.name = "error", 2507 2507 .attr.mode = S_IRUSR | S_IWUSR, 2508 2508 .size = 0, 2509 - .read_new = error_state_read, 2510 - .write_new = error_state_write, 2509 + .read = error_state_read, 2510 + .write = error_state_write, 2511 2511 }; 2512 2512 2513 2513 void i915_gpu_error_sysfs_setup(struct drm_i915_private *i915)
+4 -4
drivers/gpu/drm/i915/i915_sysfs.c
··· 140 140 static const struct bin_attribute dpf_attrs = { 141 141 .attr = {.name = "l3_parity", .mode = (S_IRUSR | S_IWUSR)}, 142 142 .size = GEN7_L3LOG_SIZE, 143 - .read_new = i915_l3_read, 144 - .write_new = i915_l3_write, 143 + .read = i915_l3_read, 144 + .write = i915_l3_write, 145 145 .mmap = NULL, 146 146 .private = (void *)0 147 147 }; ··· 149 149 static const struct bin_attribute dpf_attrs_1 = { 150 150 .attr = {.name = "l3_parity_slice_1", .mode = (S_IRUSR | S_IWUSR)}, 151 151 .size = GEN7_L3LOG_SIZE, 152 - .read_new = i915_l3_read, 153 - .write_new = i915_l3_write, 152 + .read = i915_l3_read, 153 + .write = i915_l3_write, 154 154 .mmap = NULL, 155 155 .private = (void *)1 156 156 };
+2 -2
drivers/gpu/drm/lima/lima_drv.c
··· 362 362 .attr.name = "error", 363 363 .attr.mode = 0600, 364 364 .size = 0, 365 - .read_new = lima_error_state_read, 366 - .write_new = lima_error_state_write, 365 + .read = lima_error_state_read, 366 + .write = lima_error_state_write, 367 367 }; 368 368 369 369 static int lima_pdev_probe(struct platform_device *pdev)
+4 -4
drivers/hid/hid-roccat-common.h
··· 71 71 static const struct bin_attribute bin_attr_ ## thingy = { \ 72 72 .attr = { .name = #thingy, .mode = 0660 }, \ 73 73 .size = SIZE, \ 74 - .read_new = roccat_common2_sysfs_read_ ## thingy, \ 75 - .write_new = roccat_common2_sysfs_write_ ## thingy \ 74 + .read = roccat_common2_sysfs_read_ ## thingy, \ 75 + .write = roccat_common2_sysfs_write_ ## thingy \ 76 76 } 77 77 78 78 #define ROCCAT_COMMON2_BIN_ATTRIBUTE_R(thingy, COMMAND, SIZE) \ ··· 80 80 static const struct bin_attribute bin_attr_ ## thingy = { \ 81 81 .attr = { .name = #thingy, .mode = 0440 }, \ 82 82 .size = SIZE, \ 83 - .read_new = roccat_common2_sysfs_read_ ## thingy, \ 83 + .read = roccat_common2_sysfs_read_ ## thingy, \ 84 84 } 85 85 86 86 #define ROCCAT_COMMON2_BIN_ATTRIBUTE_W(thingy, COMMAND, SIZE) \ ··· 88 88 static const struct bin_attribute bin_attr_ ## thingy = { \ 89 89 .attr = { .name = #thingy, .mode = 0220 }, \ 90 90 .size = SIZE, \ 91 - .write_new = roccat_common2_sysfs_write_ ## thingy \ 91 + .write = roccat_common2_sysfs_write_ ## thingy \ 92 92 } 93 93 94 94 #endif
+4 -4
drivers/hid/hid-roccat-isku.c
··· 181 181 static const struct bin_attribute bin_attr_##thingy = { \ 182 182 .attr = { .name = #thingy, .mode = 0660 }, \ 183 183 .size = ISKU_SIZE_ ## THINGY, \ 184 - .read_new = isku_sysfs_read_ ## thingy, \ 185 - .write_new = isku_sysfs_write_ ## thingy \ 184 + .read = isku_sysfs_read_ ## thingy, \ 185 + .write = isku_sysfs_write_ ## thingy \ 186 186 } 187 187 188 188 #define ISKU_BIN_ATTR_R(thingy, THINGY) \ ··· 190 190 static const struct bin_attribute bin_attr_##thingy = { \ 191 191 .attr = { .name = #thingy, .mode = 0440 }, \ 192 192 .size = ISKU_SIZE_ ## THINGY, \ 193 - .read_new = isku_sysfs_read_ ## thingy, \ 193 + .read = isku_sysfs_read_ ## thingy, \ 194 194 } 195 195 196 196 #define ISKU_BIN_ATTR_W(thingy, THINGY) \ ··· 198 198 static const struct bin_attribute bin_attr_##thingy = { \ 199 199 .attr = { .name = #thingy, .mode = 0220 }, \ 200 200 .size = ISKU_SIZE_ ## THINGY, \ 201 - .write_new = isku_sysfs_write_ ## thingy \ 201 + .write = isku_sysfs_write_ ## thingy \ 202 202 } 203 203 204 204 ISKU_BIN_ATTR_RW(macro, MACRO);
+2 -2
drivers/hid/hid-roccat-kone.c
··· 385 385 static const struct bin_attribute bin_attr_profile##number = { \ 386 386 .attr = { .name = "profile" #number, .mode = 0660 }, \ 387 387 .size = sizeof(struct kone_profile), \ 388 - .read_new = kone_sysfs_read_profilex, \ 389 - .write_new = kone_sysfs_write_profilex, \ 388 + .read = kone_sysfs_read_profilex, \ 389 + .write = kone_sysfs_write_profilex, \ 390 390 .private = &profile_numbers[number-1], \ 391 391 } 392 392 PROFILE_ATTR(1);
+6 -6
drivers/hid/hid-roccat-koneplus.c
··· 153 153 static const struct bin_attribute bin_attr_##thingy = { \ 154 154 .attr = { .name = #thingy, .mode = 0660 }, \ 155 155 .size = KONEPLUS_SIZE_ ## THINGY, \ 156 - .read_new = koneplus_sysfs_read_ ## thingy, \ 157 - .write_new = koneplus_sysfs_write_ ## thingy \ 156 + .read = koneplus_sysfs_read_ ## thingy, \ 157 + .write = koneplus_sysfs_write_ ## thingy \ 158 158 } 159 159 160 160 #define KONEPLUS_BIN_ATTRIBUTE_R(thingy, THINGY) \ ··· 162 162 static const struct bin_attribute bin_attr_##thingy = { \ 163 163 .attr = { .name = #thingy, .mode = 0440 }, \ 164 164 .size = KONEPLUS_SIZE_ ## THINGY, \ 165 - .read_new = koneplus_sysfs_read_ ## thingy, \ 165 + .read = koneplus_sysfs_read_ ## thingy, \ 166 166 } 167 167 168 168 #define KONEPLUS_BIN_ATTRIBUTE_W(thingy, THINGY) \ ··· 170 170 static const struct bin_attribute bin_attr_##thingy = { \ 171 171 .attr = { .name = #thingy, .mode = 0220 }, \ 172 172 .size = KONEPLUS_SIZE_ ## THINGY, \ 173 - .write_new = koneplus_sysfs_write_ ## thingy \ 173 + .write = koneplus_sysfs_write_ ## thingy \ 174 174 } 175 175 KONEPLUS_BIN_ATTRIBUTE_W(control, CONTROL); 176 176 KONEPLUS_BIN_ATTRIBUTE_W(talk, TALK); ··· 222 222 static const struct bin_attribute bin_attr_profile##number##_settings = { \ 223 223 .attr = { .name = "profile" #number "_settings", .mode = 0440 }, \ 224 224 .size = KONEPLUS_SIZE_PROFILE_SETTINGS, \ 225 - .read_new = koneplus_sysfs_read_profilex_settings, \ 225 + .read = koneplus_sysfs_read_profilex_settings, \ 226 226 .private = &profile_numbers[number-1], \ 227 227 }; \ 228 228 static const struct bin_attribute bin_attr_profile##number##_buttons = { \ 229 229 .attr = { .name = "profile" #number "_buttons", .mode = 0440 }, \ 230 230 .size = KONEPLUS_SIZE_PROFILE_BUTTONS, \ 231 - .read_new = koneplus_sysfs_read_profilex_buttons, \ 231 + .read = koneplus_sysfs_read_profilex_buttons, \ 232 232 .private = &profile_numbers[number-1], \ 233 233 }; 234 234 PROFILE_ATTR(1);
+5 -5
drivers/hid/hid-roccat-kovaplus.c
··· 196 196 static const struct bin_attribute bin_attr_##thingy = { \ 197 197 .attr = { .name = #thingy, .mode = 0660 }, \ 198 198 .size = KOVAPLUS_SIZE_ ## THINGY, \ 199 - .read_new = kovaplus_sysfs_read_ ## thingy, \ 200 - .write_new = kovaplus_sysfs_write_ ## thingy \ 199 + .read = kovaplus_sysfs_read_ ## thingy, \ 200 + .write = kovaplus_sysfs_write_ ## thingy \ 201 201 } 202 202 203 203 #define KOVAPLUS_BIN_ATTRIBUTE_W(thingy, THINGY) \ ··· 205 205 static const struct bin_attribute bin_attr_##thingy = { \ 206 206 .attr = { .name = #thingy, .mode = 0220 }, \ 207 207 .size = KOVAPLUS_SIZE_ ## THINGY, \ 208 - .write_new = kovaplus_sysfs_write_ ## thingy \ 208 + .write = kovaplus_sysfs_write_ ## thingy \ 209 209 } 210 210 KOVAPLUS_BIN_ATTRIBUTE_W(control, CONTROL); 211 211 KOVAPLUS_BIN_ATTRIBUTE_RW(info, INFO); ··· 252 252 static const struct bin_attribute bin_attr_profile##number##_settings = { \ 253 253 .attr = { .name = "profile" #number "_settings", .mode = 0440 }, \ 254 254 .size = KOVAPLUS_SIZE_PROFILE_SETTINGS, \ 255 - .read_new = kovaplus_sysfs_read_profilex_settings, \ 255 + .read = kovaplus_sysfs_read_profilex_settings, \ 256 256 .private = &profile_numbers[number-1], \ 257 257 }; \ 258 258 static const struct bin_attribute bin_attr_profile##number##_buttons = { \ 259 259 .attr = { .name = "profile" #number "_buttons", .mode = 0440 }, \ 260 260 .size = KOVAPLUS_SIZE_PROFILE_BUTTONS, \ 261 - .read_new = kovaplus_sysfs_read_profilex_buttons, \ 261 + .read = kovaplus_sysfs_read_profilex_buttons, \ 262 262 .private = &profile_numbers[number-1], \ 263 263 }; 264 264 PROFILE_ATTR(1);
+2 -2
drivers/hid/hid-roccat-lua.c
··· 88 88 static const struct bin_attribute lua_ ## thingy ## _attr = { \ 89 89 .attr = { .name = #thingy, .mode = 0660 }, \ 90 90 .size = LUA_SIZE_ ## THINGY, \ 91 - .read_new = lua_sysfs_read_ ## thingy, \ 92 - .write_new = lua_sysfs_write_ ## thingy \ 91 + .read = lua_sysfs_read_ ## thingy, \ 92 + .write = lua_sysfs_write_ ## thingy \ 93 93 }; 94 94 95 95 LUA_BIN_ATTRIBUTE_RW(control, CONTROL)
+6 -6
drivers/hid/hid-roccat-pyra.c
··· 154 154 static const struct bin_attribute bin_attr_##thingy = { \ 155 155 .attr = { .name = #thingy, .mode = 0660 }, \ 156 156 .size = PYRA_SIZE_ ## THINGY, \ 157 - .read_new = pyra_sysfs_read_ ## thingy, \ 158 - .write_new = pyra_sysfs_write_ ## thingy \ 157 + .read = pyra_sysfs_read_ ## thingy, \ 158 + .write = pyra_sysfs_write_ ## thingy \ 159 159 } 160 160 161 161 #define PYRA_BIN_ATTRIBUTE_R(thingy, THINGY) \ ··· 163 163 static const struct bin_attribute bin_attr_##thingy = { \ 164 164 .attr = { .name = #thingy, .mode = 0440 }, \ 165 165 .size_new = PYRA_SIZE_ ## THINGY, \ 166 - .read_new = pyra_sysfs_read_ ## thingy, \ 166 + .read = pyra_sysfs_read_ ## thingy, \ 167 167 } 168 168 169 169 #define PYRA_BIN_ATTRIBUTE_W(thingy, THINGY) \ ··· 171 171 static const struct bin_attribute bin_attr_##thingy = { \ 172 172 .attr = { .name = #thingy, .mode = 0220 }, \ 173 173 .size = PYRA_SIZE_ ## THINGY, \ 174 - .write_new = pyra_sysfs_write_ ## thingy \ 174 + .write = pyra_sysfs_write_ ## thingy \ 175 175 } 176 176 177 177 PYRA_BIN_ATTRIBUTE_W(control, CONTROL); ··· 219 219 static const struct bin_attribute bin_attr_profile##number##_settings = { \ 220 220 .attr = { .name = "profile" #number "_settings", .mode = 0440 }, \ 221 221 .size = PYRA_SIZE_PROFILE_SETTINGS, \ 222 - .read_new = pyra_sysfs_read_profilex_settings, \ 222 + .read = pyra_sysfs_read_profilex_settings, \ 223 223 .private = &profile_numbers[number-1], \ 224 224 }; \ 225 225 static const struct bin_attribute bin_attr_profile##number##_buttons = { \ 226 226 .attr = { .name = "profile" #number "_buttons", .mode = 0440 }, \ 227 227 .size = PYRA_SIZE_PROFILE_BUTTONS, \ 228 - .read_new = pyra_sysfs_read_profilex_buttons, \ 228 + .read = pyra_sysfs_read_profilex_buttons, \ 229 229 .private = &profile_numbers[number-1], \ 230 230 }; 231 231 PROFILE_ATTR(1);
+2 -2
drivers/i2c/i2c-slave-eeprom.c
··· 165 165 sysfs_bin_attr_init(&eeprom->bin); 166 166 eeprom->bin.attr.name = "slave-eeprom"; 167 167 eeprom->bin.attr.mode = S_IRUSR | S_IWUSR; 168 - eeprom->bin.read_new = i2c_slave_eeprom_bin_read; 169 - eeprom->bin.write_new = i2c_slave_eeprom_bin_write; 168 + eeprom->bin.read = i2c_slave_eeprom_bin_read; 169 + eeprom->bin.write = i2c_slave_eeprom_bin_write; 170 170 eeprom->bin.size = size; 171 171 172 172 ret = sysfs_create_bin_file(&client->dev.kobj, &eeprom->bin);
+1 -1
drivers/media/pci/solo6x10/solo6x10-core.c
··· 432 432 sysfs_attr_init(&sdram_attr->attr); 433 433 sdram_attr->attr.name = "sdram"; 434 434 sdram_attr->attr.mode = 0440; 435 - sdram_attr->read_new = sdram_show; 435 + sdram_attr->read = sdram_show; 436 436 sdram_attr->size = solo_dev->sdram_size; 437 437 438 438 if (device_create_bin_file(dev, sdram_attr)) {
+2 -2
drivers/misc/ds1682.c
··· 194 194 .mode = S_IRUGO | S_IWUSR, 195 195 }, 196 196 .size = DS1682_EEPROM_SIZE, 197 - .read_new = ds1682_eeprom_read, 198 - .write_new = ds1682_eeprom_write, 197 + .read = ds1682_eeprom_read, 198 + .write = ds1682_eeprom_write, 199 199 }; 200 200 201 201 static int ds1682_nvmem_read(void *priv, unsigned int offset, void *val,
+1 -1
drivers/misc/eeprom/max6875.c
··· 127 127 .mode = S_IRUGO, 128 128 }, 129 129 .size = USER_EEPROM_SIZE, 130 - .read_new = max6875_read, 130 + .read = max6875_read, 131 131 }; 132 132 133 133 static int max6875_probe(struct i2c_client *client)
+1 -1
drivers/misc/ocxl/sysfs.c
··· 155 155 info->attr_global_mmio.attr.name = "global_mmio_area"; 156 156 info->attr_global_mmio.attr.mode = 0600; 157 157 info->attr_global_mmio.size = info->afu->config.global_mmio_size; 158 - info->attr_global_mmio.read_new = global_mmio_read; 158 + info->attr_global_mmio.read = global_mmio_read; 159 159 info->attr_global_mmio.mmap = global_mmio_mmap; 160 160 rc = device_create_bin_file(&info->dev, &info->attr_global_mmio); 161 161 if (rc) {
+2 -2
drivers/misc/pch_phub.c
··· 655 655 .mode = S_IRUGO | S_IWUSR, 656 656 }, 657 657 .size = PCH_PHUB_OROM_SIZE + 1, 658 - .read_new = pch_phub_bin_read, 659 - .write_new = pch_phub_bin_write, 658 + .read = pch_phub_bin_read, 659 + .write = pch_phub_bin_write, 660 660 }; 661 661 662 662 static int pch_phub_probe(struct pci_dev *pdev,
+2 -2
drivers/misc/sram.c
··· 83 83 return -ENOMEM; 84 84 85 85 part->battr.attr.mode = S_IRUSR | S_IWUSR; 86 - part->battr.read_new = sram_read; 87 - part->battr.write_new = sram_write; 86 + part->battr.read = sram_read; 87 + part->battr.write = sram_write; 88 88 part->battr.size = block->size; 89 89 90 90 return device_create_bin_file(sram->dev, &part->battr);
+5 -5
drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
··· 2946 2946 static const struct bin_attribute bin_attr_crb = { 2947 2947 .attr = { .name = "crb", .mode = 0644 }, 2948 2948 .size = 0, 2949 - .read_new = netxen_sysfs_read_crb, 2950 - .write_new = netxen_sysfs_write_crb, 2949 + .read = netxen_sysfs_read_crb, 2950 + .write = netxen_sysfs_write_crb, 2951 2951 }; 2952 2952 2953 2953 static const struct bin_attribute bin_attr_mem = { 2954 2954 .attr = { .name = "mem", .mode = 0644 }, 2955 2955 .size = 0, 2956 - .read_new = netxen_sysfs_read_mem, 2957 - .write_new = netxen_sysfs_write_mem, 2956 + .read = netxen_sysfs_read_mem, 2957 + .write = netxen_sysfs_write_mem, 2958 2958 }; 2959 2959 2960 2960 static ssize_t ··· 3082 3082 static const struct bin_attribute bin_attr_dimm = { 3083 3083 .attr = { .name = "dimm", .mode = 0644 }, 3084 3084 .size = sizeof(struct netxen_dimm_cfg), 3085 - .read_new = netxen_sysfs_read_dimm, 3085 + .read = netxen_sysfs_read_dimm, 3086 3086 }; 3087 3087 3088 3088
+17 -17
drivers/net/ethernet/qlogic/qlcnic/qlcnic_sysfs.c
··· 1195 1195 static const struct bin_attribute bin_attr_crb = { 1196 1196 .attr = { .name = "crb", .mode = 0644 }, 1197 1197 .size = 0, 1198 - .read_new = qlcnic_sysfs_read_crb, 1199 - .write_new = qlcnic_sysfs_write_crb, 1198 + .read = qlcnic_sysfs_read_crb, 1199 + .write = qlcnic_sysfs_write_crb, 1200 1200 }; 1201 1201 1202 1202 static const struct bin_attribute bin_attr_mem = { 1203 1203 .attr = { .name = "mem", .mode = 0644 }, 1204 1204 .size = 0, 1205 - .read_new = qlcnic_sysfs_read_mem, 1206 - .write_new = qlcnic_sysfs_write_mem, 1205 + .read = qlcnic_sysfs_read_mem, 1206 + .write = qlcnic_sysfs_write_mem, 1207 1207 }; 1208 1208 1209 1209 static const struct bin_attribute bin_attr_npar_config = { 1210 1210 .attr = { .name = "npar_config", .mode = 0644 }, 1211 1211 .size = 0, 1212 - .read_new = qlcnic_sysfs_read_npar_config, 1213 - .write_new = qlcnic_sysfs_write_npar_config, 1212 + .read = qlcnic_sysfs_read_npar_config, 1213 + .write = qlcnic_sysfs_write_npar_config, 1214 1214 }; 1215 1215 1216 1216 static const struct bin_attribute bin_attr_pci_config = { 1217 1217 .attr = { .name = "pci_config", .mode = 0644 }, 1218 1218 .size = 0, 1219 - .read_new = qlcnic_sysfs_read_pci_config, 1219 + .read = qlcnic_sysfs_read_pci_config, 1220 1220 }; 1221 1221 1222 1222 static const struct bin_attribute bin_attr_port_stats = { 1223 1223 .attr = { .name = "port_stats", .mode = 0644 }, 1224 1224 .size = 0, 1225 - .read_new = qlcnic_sysfs_get_port_stats, 1226 - .write_new = qlcnic_sysfs_clear_port_stats, 1225 + .read = qlcnic_sysfs_get_port_stats, 1226 + .write = qlcnic_sysfs_clear_port_stats, 1227 1227 }; 1228 1228 1229 1229 static const struct bin_attribute bin_attr_esw_stats = { 1230 1230 .attr = { .name = "esw_stats", .mode = 0644 }, 1231 1231 .size = 0, 1232 - .read_new = qlcnic_sysfs_get_esw_stats, 1233 - .write_new = qlcnic_sysfs_clear_esw_stats, 1232 + .read = qlcnic_sysfs_get_esw_stats, 1233 + .write = qlcnic_sysfs_clear_esw_stats, 1234 1234 }; 1235 1235 1236 1236 static const struct bin_attribute bin_attr_esw_config = { 1237 1237 .attr = { .name = "esw_config", .mode = 0644 }, 1238 1238 .size = 0, 1239 - .read_new = qlcnic_sysfs_read_esw_config, 1240 - .write_new = qlcnic_sysfs_write_esw_config, 1239 + .read = qlcnic_sysfs_read_esw_config, 1240 + .write = qlcnic_sysfs_write_esw_config, 1241 1241 }; 1242 1242 1243 1243 static const struct bin_attribute bin_attr_pm_config = { 1244 1244 .attr = { .name = "pm_config", .mode = 0644 }, 1245 1245 .size = 0, 1246 - .read_new = qlcnic_sysfs_read_pm_config, 1247 - .write_new = qlcnic_sysfs_write_pm_config, 1246 + .read = qlcnic_sysfs_read_pm_config, 1247 + .write = qlcnic_sysfs_write_pm_config, 1248 1248 }; 1249 1249 1250 1250 static const struct bin_attribute bin_attr_flash = { 1251 1251 .attr = { .name = "flash", .mode = 0644 }, 1252 1252 .size = 0, 1253 - .read_new = qlcnic_83xx_sysfs_flash_read_handler, 1254 - .write_new = qlcnic_83xx_sysfs_flash_write_handler, 1253 + .read = qlcnic_83xx_sysfs_flash_read_handler, 1254 + .write = qlcnic_83xx_sysfs_flash_write_handler, 1255 1255 }; 1256 1256 1257 1257 #ifdef CONFIG_QLCNIC_HWMON
+2 -2
drivers/net/phy/spi_ks8995.c
··· 401 401 .mode = 0600, 402 402 }, 403 403 .size = KS8995_REGS_SIZE, 404 - .read_new = ks8995_registers_read, 405 - .write_new = ks8995_registers_write, 404 + .read = ks8995_registers_read, 405 + .write = ks8995_registers_write, 406 406 }; 407 407 408 408 /* ------------------------------------------------------------------------ */
+1 -1
drivers/net/wireless/ti/wlcore/sysfs.c
··· 121 121 122 122 static const struct bin_attribute fwlog_attr = { 123 123 .attr = { .name = "fwlog", .mode = 0400 }, 124 - .read_new = wl1271_sysfs_read_fwlog, 124 + .read = wl1271_sysfs_read_fwlog, 125 125 }; 126 126 127 127 int wlcore_sysfs_init(struct wl1271 *wl)
+5 -5
drivers/nvmem/core.c
··· 376 376 .name = "nvmem", 377 377 .mode = 0644, 378 378 }, 379 - .read_new = bin_attr_nvmem_read, 380 - .write_new = bin_attr_nvmem_write, 379 + .read = bin_attr_nvmem_read, 380 + .write = bin_attr_nvmem_write, 381 381 }; 382 382 383 383 static const struct bin_attribute *const nvmem_bin_attributes[] = { ··· 402 402 .attr = { 403 403 .name = "eeprom", 404 404 }, 405 - .read_new = bin_attr_nvmem_read, 406 - .write_new = bin_attr_nvmem_write, 405 + .read = bin_attr_nvmem_read, 406 + .write = bin_attr_nvmem_write, 407 407 }; 408 408 409 409 /* ··· 492 492 entry->bit_offset); 493 493 attrs[i].attr.mode = 0444 & nvmem_bin_attr_get_umode(nvmem); 494 494 attrs[i].size = entry->bytes; 495 - attrs[i].read_new = &nvmem_cell_attr_read; 495 + attrs[i].read = &nvmem_cell_attr_read; 496 496 attrs[i].private = entry; 497 497 if (!attrs[i].attr.name) { 498 498 ret = -ENOMEM;
+1 -1
drivers/of/kobj.c
··· 77 77 pp->attr.attr.name = safe_name(&np->kobj, pp->name); 78 78 pp->attr.attr.mode = secure ? 0400 : 0444; 79 79 pp->attr.size = secure ? 0 : pp->length; 80 - pp->attr.read_new = of_node_property_read; 80 + pp->attr.read = of_node_property_read; 81 81 82 82 rc = sysfs_create_bin_file(&np->kobj, &pp->attr); 83 83 WARN(rc, "error adding attribute %s to node %pOF\n", pp->name, np);
+1 -1
drivers/pci/hotplug/acpiphp_ibm.c
··· 98 98 .name = "apci_table", 99 99 .mode = S_IRUGO, 100 100 }, 101 - .read_new = ibm_read_apci_table, 101 + .read = ibm_read_apci_table, 102 102 .write = NULL, 103 103 }; 104 104 static struct acpiphp_attention_info ibm_attention_info =
+4 -4
drivers/pci/pci-sysfs.c
··· 1004 1004 b->legacy_io->attr.name = "legacy_io"; 1005 1005 b->legacy_io->size = 0xffff; 1006 1006 b->legacy_io->attr.mode = 0600; 1007 - b->legacy_io->read_new = pci_read_legacy_io; 1008 - b->legacy_io->write_new = pci_write_legacy_io; 1007 + b->legacy_io->read = pci_read_legacy_io; 1008 + b->legacy_io->write = pci_write_legacy_io; 1009 1009 /* See pci_create_attr() for motivation */ 1010 1010 b->legacy_io->llseek = pci_llseek_resource; 1011 1011 b->legacy_io->mmap = pci_mmap_legacy_io; ··· 1211 1211 } else { 1212 1212 sprintf(res_attr_name, "resource%d", num); 1213 1213 if (pci_resource_flags(pdev, num) & IORESOURCE_IO) { 1214 - res_attr->read_new = pci_read_resource_io; 1215 - res_attr->write_new = pci_write_resource_io; 1214 + res_attr->read = pci_read_resource_io; 1215 + res_attr->write = pci_write_resource_io; 1216 1216 if (arch_can_pci_mmap_io()) 1217 1217 res_attr->mmap = pci_mmap_resource_uc; 1218 1218 } else {
+2 -2
drivers/pcmcia/cistpl.c
··· 1605 1605 const struct bin_attribute pccard_cis_attr = { 1606 1606 .attr = { .name = "cis", .mode = S_IRUGO | S_IWUSR }, 1607 1607 .size = 0x200, 1608 - .read_new = pccard_show_cis, 1609 - .write_new = pccard_store_cis, 1608 + .read = pccard_show_cis, 1609 + .write = pccard_store_cis, 1610 1610 };
+1 -1
drivers/platform/mellanox/mlxbf-bootctl.c
··· 993 993 994 994 static const struct bin_attribute mlxbf_bootctl_bootfifo_sysfs_attr = { 995 995 .attr = { .name = "bootfifo", .mode = 0400 }, 996 - .read_new = mlxbf_bootctl_bootfifo_read, 996 + .read = mlxbf_bootctl_bootfifo_read, 997 997 }; 998 998 999 999 static bool mlxbf_bootctl_guid_match(const guid_t *guid,
+1 -1
drivers/platform/x86/amd/hsmp/acpi.c
··· 509 509 510 510 static const struct bin_attribute hsmp_metric_tbl_attr = { 511 511 .attr = { .name = HSMP_METRICS_TABLE_NAME, .mode = 0444}, 512 - .read_new = hsmp_metric_tbl_acpi_read, 512 + .read = hsmp_metric_tbl_acpi_read, 513 513 .size = sizeof(struct hsmp_metric_table), 514 514 }; 515 515
+1 -1
drivers/platform/x86/amd/hsmp/plat.c
··· 91 91 static const struct bin_attribute attr##index = { \ 92 92 .attr = { .name = HSMP_METRICS_TABLE_NAME, .mode = 0444}, \ 93 93 .private = (void *)index, \ 94 - .read_new = hsmp_metric_tbl_plat_read, \ 94 + .read = hsmp_metric_tbl_plat_read, \ 95 95 .size = sizeof(struct hsmp_metric_table), \ 96 96 }; \ 97 97 static const struct bin_attribute _list[] = { \
+1 -1
drivers/platform/x86/intel/pmt/class.c
··· 308 308 entry->pmt_bin_attr.attr.name = ns->name; 309 309 entry->pmt_bin_attr.attr.mode = 0440; 310 310 entry->pmt_bin_attr.mmap = intel_pmt_mmap; 311 - entry->pmt_bin_attr.read_new = intel_pmt_read; 311 + entry->pmt_bin_attr.read = intel_pmt_read; 312 312 entry->pmt_bin_attr.size = entry->size; 313 313 314 314 ret = sysfs_create_bin_file(&dev->kobj, &entry->pmt_bin_attr);
+4 -4
drivers/power/supply/ds2780_battery.c
··· 660 660 .mode = S_IRUGO | S_IWUSR, 661 661 }, 662 662 .size = DS2780_PARAM_EEPROM_SIZE, 663 - .read_new = ds2780_read_param_eeprom_bin, 664 - .write_new = ds2780_write_param_eeprom_bin, 663 + .read = ds2780_read_param_eeprom_bin, 664 + .write = ds2780_write_param_eeprom_bin, 665 665 }; 666 666 667 667 static ssize_t ds2780_read_user_eeprom_bin(struct file *filp, ··· 705 705 .mode = S_IRUGO | S_IWUSR, 706 706 }, 707 707 .size = DS2780_USER_EEPROM_SIZE, 708 - .read_new = ds2780_read_user_eeprom_bin, 709 - .write_new = ds2780_write_user_eeprom_bin, 708 + .read = ds2780_read_user_eeprom_bin, 709 + .write = ds2780_write_user_eeprom_bin, 710 710 }; 711 711 712 712 static DEVICE_ATTR(pmod_enabled, S_IRUGO | S_IWUSR, ds2780_get_pmod_enabled,
+4 -4
drivers/power/supply/ds2781_battery.c
··· 662 662 .mode = S_IRUGO | S_IWUSR, 663 663 }, 664 664 .size = DS2781_PARAM_EEPROM_SIZE, 665 - .read_new = ds2781_read_param_eeprom_bin, 666 - .write_new = ds2781_write_param_eeprom_bin, 665 + .read = ds2781_read_param_eeprom_bin, 666 + .write = ds2781_write_param_eeprom_bin, 667 667 }; 668 668 669 669 static ssize_t ds2781_read_user_eeprom_bin(struct file *filp, ··· 708 708 .mode = S_IRUGO | S_IWUSR, 709 709 }, 710 710 .size = DS2781_USER_EEPROM_SIZE, 711 - .read_new = ds2781_read_user_eeprom_bin, 712 - .write_new = ds2781_write_user_eeprom_bin, 711 + .read = ds2781_read_user_eeprom_bin, 712 + .write = ds2781_write_user_eeprom_bin, 713 713 }; 714 714 715 715 static DEVICE_ATTR(pmod_enabled, S_IRUGO | S_IWUSR, ds2781_get_pmod_enabled,
+1 -1
drivers/power/supply/olpc_battery.c
··· 553 553 .mode = S_IRUGO, 554 554 }, 555 555 .size = EEPROM_SIZE, 556 - .read_new = olpc_bat_eeprom_read, 556 + .read = olpc_bat_eeprom_read, 557 557 }; 558 558 559 559 /* Allow userspace to see the specific error value pulled from the EC */
+2 -2
drivers/rapidio/rio-sysfs.c
··· 247 247 .mode = S_IRUGO | S_IWUSR, 248 248 }, 249 249 .size = RIO_MAINT_SPACE_SZ, 250 - .read_new = rio_read_config, 251 - .write_new = rio_write_config, 250 + .read = rio_read_config, 251 + .write = rio_write_config, 252 252 }; 253 253 254 254 static const struct bin_attribute *const rio_dev_bin_attrs[] = {
+1 -1
drivers/s390/char/sclp_config.c
··· 142 142 .name = "event_data", 143 143 .mode = S_IWUSR, 144 144 }, 145 - .write_new = sysfs_ofb_data_write, 145 + .write = sysfs_ofb_data_write, 146 146 }; 147 147 #endif 148 148
+1 -1
drivers/s390/char/sclp_sd.c
··· 539 539 sysfs_bin_attr_init(&sd_file->data_attr); 540 540 sd_file->data_attr.attr.name = "data"; 541 541 sd_file->data_attr.attr.mode = 0444; 542 - sd_file->data_attr.read_new = data_read; 542 + sd_file->data_attr.read = data_read; 543 543 544 544 rc = sysfs_create_bin_file(&sd_file->kobj, &sd_file->data_attr); 545 545 if (rc) {
+2 -2
drivers/scsi/3w-sas.c
··· 122 122 .mode = S_IRUSR, 123 123 }, 124 124 .size = 0, 125 - .read_new = twl_sysfs_aen_read 125 + .read = twl_sysfs_aen_read 126 126 }; 127 127 128 128 /* This function returns driver compatibility info through sysfs */ ··· 153 153 .mode = S_IRUSR, 154 154 }, 155 155 .size = 0, 156 - .read_new = twl_sysfs_compat_info 156 + .read = twl_sysfs_compat_info 157 157 }; 158 158 159 159 /* Show some statistics about the card */
+3 -3
drivers/scsi/arcmsr/arcmsr_attr.c
··· 194 194 .mode = S_IRUSR , 195 195 }, 196 196 .size = ARCMSR_API_DATA_BUFLEN, 197 - .read_new = arcmsr_sysfs_iop_message_read, 197 + .read = arcmsr_sysfs_iop_message_read, 198 198 }; 199 199 200 200 static const struct bin_attribute arcmsr_sysfs_message_write_attr = { ··· 203 203 .mode = S_IWUSR, 204 204 }, 205 205 .size = ARCMSR_API_DATA_BUFLEN, 206 - .write_new = arcmsr_sysfs_iop_message_write, 206 + .write = arcmsr_sysfs_iop_message_write, 207 207 }; 208 208 209 209 static const struct bin_attribute arcmsr_sysfs_message_clear_attr = { ··· 212 212 .mode = S_IWUSR, 213 213 }, 214 214 .size = 1, 215 - .write_new = arcmsr_sysfs_iop_message_clear, 215 + .write = arcmsr_sysfs_iop_message_clear, 216 216 }; 217 217 218 218 int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *acb)
+3 -3
drivers/scsi/esas2r/esas2r_main.c
··· 215 215 .attr = \ 216 216 { .name = __stringify(_name), .mode = S_IRUSR | S_IWUSR }, \ 217 217 .size = 0, \ 218 - .read_new = read_ ## _name, \ 219 - .write_new = write_ ## _name } 218 + .read = read_ ## _name, \ 219 + .write = write_ ## _name } 220 220 221 221 ESAS2R_RW_BIN_ATTR(fw); 222 222 ESAS2R_RW_BIN_ATTR(fs); ··· 227 227 const struct bin_attribute bin_attr_default_nvram = { 228 228 .attr = { .name = "default_nvram", .mode = S_IRUGO }, 229 229 .size = 0, 230 - .read_new = read_default_nvram, 230 + .read = read_default_nvram, 231 231 .write = NULL 232 232 }; 233 233
+1 -1
drivers/scsi/ibmvscsi/ibmvfc.c
··· 3670 3670 .mode = S_IRUGO, 3671 3671 }, 3672 3672 .size = 0, 3673 - .read_new = ibmvfc_read_trace, 3673 + .read = ibmvfc_read_trace, 3674 3674 }; 3675 3675 #endif 3676 3676
+5 -5
drivers/scsi/ipr.c
··· 3389 3389 .mode = S_IRUGO, 3390 3390 }, 3391 3391 .size = 0, 3392 - .read_new = ipr_read_trace, 3392 + .read = ipr_read_trace, 3393 3393 }; 3394 3394 #endif 3395 3395 ··· 4140 4140 .mode = S_IRUGO | S_IWUSR, 4141 4141 }, 4142 4142 .size = 0, 4143 - .read_new = ipr_read_async_err_log, 4144 - .write_new = ipr_next_async_err_log 4143 + .read = ipr_read_async_err_log, 4144 + .write = ipr_next_async_err_log 4145 4145 }; 4146 4146 4147 4147 static struct attribute *ipr_ioa_attrs[] = { ··· 4391 4391 .mode = S_IRUSR | S_IWUSR, 4392 4392 }, 4393 4393 .size = 0, 4394 - .read_new = ipr_read_dump, 4395 - .write_new = ipr_write_dump 4394 + .read = ipr_read_dump, 4395 + .write = ipr_write_dump 4396 4396 }; 4397 4397 #else 4398 4398 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
+4 -4
drivers/scsi/lpfc/lpfc_attr.c
··· 6420 6420 .mode = S_IRUSR | S_IWUSR, 6421 6421 }, 6422 6422 .size = 256, 6423 - .read_new = sysfs_ctlreg_read, 6424 - .write_new = sysfs_ctlreg_write, 6423 + .read = sysfs_ctlreg_read, 6424 + .write = sysfs_ctlreg_write, 6425 6425 }; 6426 6426 6427 6427 /** ··· 6478 6478 .mode = S_IRUSR | S_IWUSR, 6479 6479 }, 6480 6480 .size = MAILBOX_SYSFS_MAX, 6481 - .read_new = sysfs_mbox_read, 6482 - .write_new = sysfs_mbox_write, 6481 + .read = sysfs_mbox_read, 6482 + .write = sysfs_mbox_write, 6483 6483 }; 6484 6484 6485 6485 /**
+2 -2
drivers/scsi/qedf/qedf_attr.c
··· 166 166 .mode = S_IRUSR | S_IWUSR, 167 167 }, 168 168 .size = 0, 169 - .read_new = qedf_sysfs_read_grcdump, 170 - .write_new = qedf_sysfs_write_grcdump, 169 + .read = qedf_sysfs_read_grcdump, 170 + .write = qedf_sysfs_write_grcdump, 171 171 }; 172 172 173 173 static struct sysfs_bin_attrs bin_file_entries[] = {
+14 -14
drivers/scsi/qla2xxx/qla_attr.c
··· 174 174 .mode = S_IRUSR | S_IWUSR, 175 175 }, 176 176 .size = 0, 177 - .read_new = qla2x00_sysfs_read_fw_dump, 178 - .write_new = qla2x00_sysfs_write_fw_dump, 177 + .read = qla2x00_sysfs_read_fw_dump, 178 + .write = qla2x00_sysfs_write_fw_dump, 179 179 }; 180 180 181 181 static ssize_t ··· 288 288 .mode = S_IRUSR | S_IWUSR, 289 289 }, 290 290 .size = 512, 291 - .read_new = qla2x00_sysfs_read_nvram, 292 - .write_new = qla2x00_sysfs_write_nvram, 291 + .read = qla2x00_sysfs_read_nvram, 292 + .write = qla2x00_sysfs_write_nvram, 293 293 }; 294 294 295 295 static ssize_t ··· 350 350 .mode = S_IRUSR | S_IWUSR, 351 351 }, 352 352 .size = 0, 353 - .read_new = qla2x00_sysfs_read_optrom, 354 - .write_new = qla2x00_sysfs_write_optrom, 353 + .read = qla2x00_sysfs_read_optrom, 354 + .write = qla2x00_sysfs_write_optrom, 355 355 }; 356 356 357 357 static ssize_t ··· 535 535 .mode = S_IWUSR, 536 536 }, 537 537 .size = 0, 538 - .write_new = qla2x00_sysfs_write_optrom_ctl, 538 + .write = qla2x00_sysfs_write_optrom_ctl, 539 539 }; 540 540 541 541 static ssize_t ··· 648 648 .mode = S_IRUSR | S_IWUSR, 649 649 }, 650 650 .size = 0, 651 - .read_new = qla2x00_sysfs_read_vpd, 652 - .write_new = qla2x00_sysfs_write_vpd, 651 + .read = qla2x00_sysfs_read_vpd, 652 + .write = qla2x00_sysfs_write_vpd, 653 653 }; 654 654 655 655 static ssize_t ··· 685 685 .mode = S_IRUSR | S_IWUSR, 686 686 }, 687 687 .size = SFP_DEV_SIZE, 688 - .read_new = qla2x00_sysfs_read_sfp, 688 + .read = qla2x00_sysfs_read_sfp, 689 689 }; 690 690 691 691 static ssize_t ··· 829 829 .mode = S_IWUSR, 830 830 }, 831 831 .size = 0, 832 - .write_new = qla2x00_sysfs_write_reset, 832 + .write = qla2x00_sysfs_write_reset, 833 833 }; 834 834 835 835 static ssize_t ··· 872 872 .mode = S_IWUSR, 873 873 }, 874 874 .size = 0, 875 - .write_new = qla2x00_issue_logo, 875 + .write = qla2x00_issue_logo, 876 876 }; 877 877 878 878 static ssize_t ··· 935 935 .mode = S_IRUSR, 936 936 }, 937 937 .size = 0, 938 - .read_new = qla2x00_sysfs_read_xgmac_stats, 938 + .read = qla2x00_sysfs_read_xgmac_stats, 939 939 }; 940 940 941 941 static ssize_t ··· 993 993 .mode = S_IRUSR, 994 994 }, 995 995 .size = 0, 996 - .read_new = qla2x00_sysfs_read_dcbx_tlv, 996 + .read = qla2x00_sysfs_read_dcbx_tlv, 997 997 }; 998 998 999 999 static struct sysfs_entry {
+2 -2
drivers/scsi/qla4xxx/ql4_attr.c
··· 110 110 .mode = S_IRUSR | S_IWUSR, 111 111 }, 112 112 .size = 0, 113 - .read_new = qla4_8xxx_sysfs_read_fw_dump, 114 - .write_new = qla4_8xxx_sysfs_write_fw_dump, 113 + .read = qla4_8xxx_sysfs_read_fw_dump, 114 + .write = qla4_8xxx_sysfs_write_fw_dump, 115 115 }; 116 116 117 117 static struct sysfs_entry {
+2 -2
drivers/scsi/scsi_sysfs.c
··· 917 917 static const struct bin_attribute dev_attr_vpd_##_page = { \ 918 918 .attr = {.name = __stringify(vpd_##_page), .mode = S_IRUGO }, \ 919 919 .size = 0, \ 920 - .read_new = show_vpd_##_page, \ 920 + .read = show_vpd_##_page, \ 921 921 }; 922 922 923 923 sdev_vpd_pg_attr(pg83); ··· 949 949 .mode = S_IRUGO, 950 950 }, 951 951 .size = 0, 952 - .read_new = show_inquiry, 952 + .read = show_inquiry, 953 953 }; 954 954 955 955 static ssize_t
+2 -2
drivers/video/fbdev/aty/radeon_base.c
··· 2227 2227 .mode = 0444, 2228 2228 }, 2229 2229 .size = EDID_LENGTH, 2230 - .read_new = radeon_show_edid1, 2230 + .read = radeon_show_edid1, 2231 2231 }; 2232 2232 2233 2233 static const struct bin_attribute edid2_attr = { ··· 2236 2236 .mode = 0444, 2237 2237 }, 2238 2238 .size = EDID_LENGTH, 2239 - .read_new = radeon_show_edid2, 2239 + .read = radeon_show_edid2, 2240 2240 }; 2241 2241 2242 2242 static int radeonfb_pci_register(struct pci_dev *pdev,
+2 -2
drivers/video/fbdev/udlfb.c
··· 1482 1482 .attr.name = "edid", 1483 1483 .attr.mode = 0666, 1484 1484 .size = EDID_LENGTH, 1485 - .read_new = edid_show, 1486 - .write_new = edid_store 1485 + .read = edid_show, 1486 + .write = edid_store 1487 1487 }; 1488 1488 1489 1489 static const struct device_attribute fb_device_attrs[] = {
+2 -2
drivers/virt/coco/guest/tsm-mr.c
··· 209 209 210 210 if (tm->mrs[i].mr_flags & TSM_MR_F_READABLE) { 211 211 bap->attr.mode |= 0444; 212 - bap->read_new = tm_digest_read; 212 + bap->read = tm_digest_read; 213 213 } 214 214 215 215 if (tm->mrs[i].mr_flags & TSM_MR_F_WRITABLE) { 216 216 bap->attr.mode |= 0200; 217 - bap->write_new = tm_digest_write; 217 + bap->write = tm_digest_write; 218 218 } 219 219 220 220 bap->size = tm->mrs[i].mr_size;
+2 -2
drivers/w1/slaves/w1_ds2406.c
··· 94 94 .mode = 0444, 95 95 }, 96 96 .size = 1, 97 - .read_new = w1_f12_read_state, 97 + .read = w1_f12_read_state, 98 98 }, 99 99 { 100 100 .attr = { ··· 102 102 .mode = 0664, 103 103 }, 104 104 .size = 1, 105 - .write_new = w1_f12_write_output, 105 + .write = w1_f12_write_output, 106 106 } 107 107 }; 108 108
+4 -4
drivers/w1/slaves/w1_ds2433.c
··· 276 276 277 277 static const struct bin_attribute bin_attr_f23_eeprom = { 278 278 .attr = { .name = "eeprom", .mode = 0644 }, 279 - .read_new = eeprom_read, 280 - .write_new = eeprom_write, 279 + .read = eeprom_read, 280 + .write = eeprom_write, 281 281 .size = W1_EEPROM_DS2433_SIZE, 282 282 }; 283 283 284 284 static const struct bin_attribute bin_attr_f43_eeprom = { 285 285 .attr = { .name = "eeprom", .mode = 0644 }, 286 - .read_new = eeprom_read, 287 - .write_new = eeprom_write, 286 + .read = eeprom_read, 287 + .write = eeprom_write, 288 288 .size = W1_EEPROM_DS28EC20_SIZE, 289 289 }; 290 290
+2 -2
drivers/w1/slaves/w1_ds2805.c
··· 267 267 .mode = 0644, 268 268 }, 269 269 .size = W1_F0D_EEPROM_SIZE, 270 - .read_new = w1_f0d_read_bin, 271 - .write_new = w1_f0d_write_bin, 270 + .read = w1_f0d_read_bin, 271 + .write = w1_f0d_write_bin, 272 272 }; 273 273 274 274 static int w1_f0d_add_slave(struct w1_slave *sl)
+1 -1
drivers/zorro/zorro-sysfs.c
··· 104 104 .mode = S_IRUGO, 105 105 }, 106 106 .size = sizeof(struct ConfigDev), 107 - .read_new = zorro_read_config, 107 + .read = zorro_read_config, 108 108 }; 109 109 110 110 static const struct bin_attribute *const zorro_device_bin_attrs[] = {
+1 -1
kernel/bpf/btf.c
··· 8183 8183 attr->attr.mode = 0444; 8184 8184 attr->size = btf->data_size; 8185 8185 attr->private = btf->data; 8186 - attr->read_new = sysfs_bin_attr_simple_read; 8186 + attr->read = sysfs_bin_attr_simple_read; 8187 8187 8188 8188 err = sysfs_create_bin_file(btf_kobj, attr); 8189 8189 if (err) {
+1 -1
kernel/bpf/sysfs_btf.c
··· 45 45 46 46 static struct bin_attribute bin_attr_btf_vmlinux __ro_after_init = { 47 47 .attr = { .name = "vmlinux", .mode = 0444, }, 48 - .read_new = sysfs_bin_attr_simple_read, 48 + .read = sysfs_bin_attr_simple_read, 49 49 .mmap = btf_sysfs_vmlinux_mmap, 50 50 }; 51 51
+2 -2
kernel/module/sysfs.c
··· 101 101 ret = -ENOMEM; 102 102 goto out; 103 103 } 104 - sattr->read_new = module_sect_read; 104 + sattr->read = module_sect_read; 105 105 sattr->private = (void *)sec->sh_addr; 106 106 sattr->size = MODULE_SECT_READ_SIZE; 107 107 sattr->attr.mode = 0400; ··· 190 190 nattr->attr.mode = 0444; 191 191 nattr->size = info->sechdrs[i].sh_size; 192 192 nattr->private = (void *)info->sechdrs[i].sh_addr; 193 - nattr->read_new = sysfs_bin_attr_simple_read; 193 + nattr->read = sysfs_bin_attr_simple_read; 194 194 *(gattr++) = nattr++; 195 195 } 196 196 ++loaded;
+1 -1
net/bridge/br_sysfs_br.c
··· 1026 1026 static const struct bin_attribute bridge_forward = { 1027 1027 .attr = { .name = SYSFS_BRIDGE_FDB, 1028 1028 .mode = 0444, }, 1029 - .read_new = brforward_read, 1029 + .read = brforward_read, 1030 1030 }; 1031 1031 1032 1032 /*