Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 's390-5.16-3' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux
Pull s390 updates from Heiko Carstens:
- Add missing Kconfig option for ftrace direct multi sample, so it can
be compiled again, and also add s390 support for this sample.
- Update Christian Borntraeger's email address.
- Various fixes for memory layout setup. Besides other this makes it
possible to load shared DCSS segments again.
- Fix copy to user space of swapped kdump oldmem.
- Remove -mstack-guard and -mstack-size compile options when building
vdso binaries. This can happen when CONFIG_VMAP_STACK is disabled and
results in broken vdso code which causes more or less random
exceptions. Also remove the not needed -nostdlib option.
- Fix memory leak on cpu hotplug and return code handling in kexec
code.
- Wire up futex_waitv system call.
- Replace snprintf with sysfs_emit where appropriate.
* tag 's390-5.16-3' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux:
ftrace/samples: add s390 support for ftrace direct multi sample
ftrace/samples: add missing Kconfig option for ftrace direct multi sample
MAINTAINERS: update email address of Christian Borntraeger
s390/kexec: fix memory leak of ipl report buffer
s390/kexec: fix return code handling
s390/dump: fix copying to user-space of swapped kdump oldmem
s390: wire up sys_futex_waitv system call
s390/vdso: filter out -mstack-guard and -mstack-size
s390/vdso: remove -nostdlib compiler flag
s390: replace snprintf in show functions with sysfs_emit
s390/boot: simplify and fix kernel memory layout setup
s390/setup: re-arrange memblock setup
s390/setup: avoid using memblock_enforce_memory_limit
s390/setup: avoid reserving memory above identity mapping
+170
-138
+3
.mailmap
+3
.mailmap
···
71
71
Chao Yu <chao@kernel.org> <yuchao0@huawei.com>
72
72
Chris Chiu <chris.chiu@canonical.com> <chiu@endlessm.com>
73
73
Chris Chiu <chris.chiu@canonical.com> <chiu@endlessos.org>
74
+
Christian Borntraeger <borntraeger@linux.ibm.com> <borntraeger@de.ibm.com>
75
+
Christian Borntraeger <borntraeger@linux.ibm.com> <cborntra@de.ibm.com>
76
+
Christian Borntraeger <borntraeger@linux.ibm.com> <borntrae@de.ibm.com>
74
77
Christophe Ricard <christophe.ricard@gmail.com>
75
78
Christoph Hellwig <hch@lst.de>
76
79
Colin Ian King <colin.king@intel.com> <colin.king@canonical.com>
+2
-2
MAINTAINERS
+2
-2
MAINTAINERS
···
10445
10445
F: arch/riscv/kvm/
10446
10446
10447
10447
KERNEL VIRTUAL MACHINE for s390 (KVM/s390)
10448
-
M: Christian Borntraeger <borntraeger@de.ibm.com>
10448
+
M: Christian Borntraeger <borntraeger@linux.ibm.com>
10449
10449
M: Janosch Frank <frankja@linux.ibm.com>
10450
10450
R: David Hildenbrand <david@redhat.com>
10451
10451
R: Claudio Imbrenda <imbrenda@linux.ibm.com>
···
16573
16573
S390
16574
16574
M: Heiko Carstens <hca@linux.ibm.com>
16575
16575
M: Vasily Gorbik <gor@linux.ibm.com>
16576
-
M: Christian Borntraeger <borntraeger@de.ibm.com>
16576
+
M: Christian Borntraeger <borntraeger@linux.ibm.com>
16577
16577
R: Alexander Gordeev <agordeev@linux.ibm.com>
16578
16578
L: linux-s390@vger.kernel.org
16579
16579
S: Supported
+2
-1
arch/s390/Kconfig
+2
-1
arch/s390/Kconfig
···
47
47
config KASAN_SHADOW_OFFSET
48
48
hex
49
49
depends on KASAN
50
-
default 0x18000000000000
50
+
default 0x1C000000000000
51
51
52
52
config S390
53
53
def_bool y
···
194
194
select HAVE_RELIABLE_STACKTRACE
195
195
select HAVE_RSEQ
196
196
select HAVE_SAMPLE_FTRACE_DIRECT
197
+
select HAVE_SAMPLE_FTRACE_DIRECT_MULTI
197
198
select HAVE_SOFTIRQ_ON_OWN_STACK
198
199
select HAVE_SYSCALL_TRACEPOINTS
199
200
select HAVE_VIRT_CPU_ACCOUNTING
+6
-4
arch/s390/Makefile
+6
-4
arch/s390/Makefile
···
77
77
KBUILD_CFLAGS_DECOMPRESSOR += $(cflags-y)
78
78
79
79
ifneq ($(call cc-option,-mstack-size=8192 -mstack-guard=128),)
80
-
cflags-$(CONFIG_CHECK_STACK) += -mstack-size=$(STACK_SIZE)
81
-
ifeq ($(call cc-option,-mstack-size=8192),)
82
-
cflags-$(CONFIG_CHECK_STACK) += -mstack-guard=$(CONFIG_STACK_GUARD)
83
-
endif
80
+
CC_FLAGS_CHECK_STACK := -mstack-size=$(STACK_SIZE)
81
+
ifeq ($(call cc-option,-mstack-size=8192),)
82
+
CC_FLAGS_CHECK_STACK += -mstack-guard=$(CONFIG_STACK_GUARD)
83
+
endif
84
+
export CC_FLAGS_CHECK_STACK
85
+
cflags-$(CONFIG_CHECK_STACK) += $(CC_FLAGS_CHECK_STACK)
84
86
endif
85
87
86
88
ifdef CONFIG_EXPOLINE
+31
-57
arch/s390/boot/startup.c
+31
-57
arch/s390/boot/startup.c
···
149
149
150
150
static void setup_kernel_memory_layout(void)
151
151
{
152
-
bool vmalloc_size_verified = false;
153
-
unsigned long vmemmap_off;
154
-
unsigned long vspace_left;
152
+
unsigned long vmemmap_start;
155
153
unsigned long rte_size;
156
154
unsigned long pages;
157
-
unsigned long vmax;
158
155
159
156
pages = ident_map_size / PAGE_SIZE;
160
157
/* vmemmap contains a multiple of PAGES_PER_SECTION struct pages */
161
158
vmemmap_size = SECTION_ALIGN_UP(pages) * sizeof(struct page);
162
159
163
160
/* choose kernel address space layout: 4 or 3 levels. */
164
-
vmemmap_off = round_up(ident_map_size, _REGION3_SIZE);
161
+
vmemmap_start = round_up(ident_map_size, _REGION3_SIZE);
165
162
if (IS_ENABLED(CONFIG_KASAN) ||
166
163
vmalloc_size > _REGION2_SIZE ||
167
-
vmemmap_off + vmemmap_size + vmalloc_size + MODULES_LEN > _REGION2_SIZE)
168
-
vmax = _REGION1_SIZE;
169
-
else
170
-
vmax = _REGION2_SIZE;
171
-
172
-
/* keep vmemmap_off aligned to a top level region table entry */
173
-
rte_size = vmax == _REGION1_SIZE ? _REGION2_SIZE : _REGION3_SIZE;
174
-
MODULES_END = vmax;
175
-
if (is_prot_virt_host()) {
176
-
/*
177
-
* forcing modules and vmalloc area under the ultravisor
178
-
* secure storage limit, so that any vmalloc allocation
179
-
* we do could be used to back secure guest storage.
180
-
*/
181
-
adjust_to_uv_max(&MODULES_END);
182
-
}
183
-
184
-
#ifdef CONFIG_KASAN
185
-
if (MODULES_END < vmax) {
186
-
/* force vmalloc and modules below kasan shadow */
187
-
MODULES_END = min(MODULES_END, KASAN_SHADOW_START);
164
+
vmemmap_start + vmemmap_size + vmalloc_size + MODULES_LEN >
165
+
_REGION2_SIZE) {
166
+
MODULES_END = _REGION1_SIZE;
167
+
rte_size = _REGION2_SIZE;
188
168
} else {
189
-
/*
190
-
* leave vmalloc and modules above kasan shadow but make
191
-
* sure they don't overlap with it
192
-
*/
193
-
vmalloc_size = min(vmalloc_size, vmax - KASAN_SHADOW_END - MODULES_LEN);
194
-
vmalloc_size_verified = true;
195
-
vspace_left = KASAN_SHADOW_START;
169
+
MODULES_END = _REGION2_SIZE;
170
+
rte_size = _REGION3_SIZE;
196
171
}
172
+
/*
173
+
* forcing modules and vmalloc area under the ultravisor
174
+
* secure storage limit, so that any vmalloc allocation
175
+
* we do could be used to back secure guest storage.
176
+
*/
177
+
adjust_to_uv_max(&MODULES_END);
178
+
#ifdef CONFIG_KASAN
179
+
/* force vmalloc and modules below kasan shadow */
180
+
MODULES_END = min(MODULES_END, KASAN_SHADOW_START);
197
181
#endif
198
182
MODULES_VADDR = MODULES_END - MODULES_LEN;
199
183
VMALLOC_END = MODULES_VADDR;
200
184
201
-
if (vmalloc_size_verified) {
202
-
VMALLOC_START = VMALLOC_END - vmalloc_size;
203
-
} else {
204
-
vmemmap_off = round_up(ident_map_size, rte_size);
185
+
/* allow vmalloc area to occupy up to about 1/2 of the rest virtual space left */
186
+
vmalloc_size = min(vmalloc_size, round_down(VMALLOC_END / 2, _REGION3_SIZE));
187
+
VMALLOC_START = VMALLOC_END - vmalloc_size;
205
188
206
-
if (vmemmap_off + vmemmap_size > VMALLOC_END ||
207
-
vmalloc_size > VMALLOC_END - vmemmap_off - vmemmap_size) {
208
-
/*
209
-
* allow vmalloc area to occupy up to 1/2 of
210
-
* the rest virtual space left.
211
-
*/
212
-
vmalloc_size = min(vmalloc_size, VMALLOC_END / 2);
213
-
}
214
-
VMALLOC_START = VMALLOC_END - vmalloc_size;
215
-
vspace_left = VMALLOC_START;
216
-
}
217
-
218
-
pages = vspace_left / (PAGE_SIZE + sizeof(struct page));
189
+
/* split remaining virtual space between 1:1 mapping & vmemmap array */
190
+
pages = VMALLOC_START / (PAGE_SIZE + sizeof(struct page));
219
191
pages = SECTION_ALIGN_UP(pages);
220
-
vmemmap_off = round_up(vspace_left - pages * sizeof(struct page), rte_size);
221
-
/* keep vmemmap left most starting from a fresh region table entry */
222
-
vmemmap_off = min(vmemmap_off, round_up(ident_map_size, rte_size));
223
-
/* take care that identity map is lower then vmemmap */
224
-
ident_map_size = min(ident_map_size, vmemmap_off);
192
+
/* keep vmemmap_start aligned to a top level region table entry */
193
+
vmemmap_start = round_down(VMALLOC_START - pages * sizeof(struct page), rte_size);
194
+
/* vmemmap_start is the future VMEM_MAX_PHYS, make sure it is within MAX_PHYSMEM */
195
+
vmemmap_start = min(vmemmap_start, 1UL << MAX_PHYSMEM_BITS);
196
+
/* make sure identity map doesn't overlay with vmemmap */
197
+
ident_map_size = min(ident_map_size, vmemmap_start);
225
198
vmemmap_size = SECTION_ALIGN_UP(ident_map_size / PAGE_SIZE) * sizeof(struct page);
226
-
VMALLOC_START = max(vmemmap_off + vmemmap_size, VMALLOC_START);
227
-
vmemmap = (struct page *)vmemmap_off;
199
+
/* make sure vmemmap doesn't overlay with vmalloc area */
200
+
VMALLOC_START = max(vmemmap_start + vmemmap_size, VMALLOC_START);
201
+
vmemmap = (struct page *)vmemmap_start;
228
202
}
229
203
230
204
/*
+6
arch/s390/include/asm/kexec.h
+6
arch/s390/include/asm/kexec.h
···
74
74
int arch_kexec_do_relocs(int r_type, void *loc, unsigned long val,
75
75
unsigned long addr);
76
76
77
+
#define ARCH_HAS_KIMAGE_ARCH
78
+
79
+
struct kimage_arch {
80
+
void *ipl_buf;
81
+
};
82
+
77
83
extern const struct kexec_file_ops s390_kexec_image_ops;
78
84
extern const struct kexec_file_ops s390_kexec_elf_ops;
79
85
+2
-2
arch/s390/kernel/crash_dump.c
+2
-2
arch/s390/kernel/crash_dump.c
···
191
191
return rc;
192
192
} else {
193
193
/* Check for swapped kdump oldmem areas */
194
-
if (oldmem_data.start && from - oldmem_data.size < oldmem_data.size) {
195
-
from -= oldmem_data.size;
194
+
if (oldmem_data.start && from - oldmem_data.start < oldmem_data.size) {
195
+
from -= oldmem_data.start;
196
196
len = min(count, oldmem_data.size - from);
197
197
} else if (oldmem_data.start && from < oldmem_data.size) {
198
198
len = min(count, oldmem_data.size - from);
+2
-1
arch/s390/kernel/ipl.c
+2
-1
arch/s390/kernel/ipl.c
···
2156
2156
2157
2157
buf = vzalloc(report->size);
2158
2158
if (!buf)
2159
-
return ERR_PTR(-ENOMEM);
2159
+
goto out;
2160
2160
ptr = buf;
2161
2161
2162
2162
memcpy(ptr, report->ipib, report->ipib->hdr.len);
···
2195
2195
}
2196
2196
2197
2197
BUG_ON(ptr > buf + report->size);
2198
+
out:
2198
2199
return buf;
2199
2200
}
2200
2201
+17
-1
arch/s390/kernel/machine_kexec_file.c
+17
-1
arch/s390/kernel/machine_kexec_file.c
···
12
12
#include <linux/kexec.h>
13
13
#include <linux/module_signature.h>
14
14
#include <linux/verification.h>
15
+
#include <linux/vmalloc.h>
15
16
#include <asm/boot_data.h>
16
17
#include <asm/ipl.h>
17
18
#include <asm/setup.h>
···
171
170
struct kexec_buf buf;
172
171
unsigned long addr;
173
172
void *ptr, *end;
173
+
int ret;
174
174
175
175
buf.image = image;
176
176
···
201
199
ptr += len;
202
200
}
203
201
202
+
ret = -ENOMEM;
204
203
buf.buffer = ipl_report_finish(data->report);
204
+
if (!buf.buffer)
205
+
goto out;
205
206
buf.bufsz = data->report->size;
206
207
buf.memsz = buf.bufsz;
208
+
image->arch.ipl_buf = buf.buffer;
207
209
208
210
data->memsz += buf.memsz;
209
211
···
215
209
data->kernel_buf + offsetof(struct lowcore, ipl_parmblock_ptr);
216
210
*lc_ipl_parmblock_ptr = (__u32)buf.mem;
217
211
218
-
return kexec_add_buffer(&buf);
212
+
ret = kexec_add_buffer(&buf);
213
+
out:
214
+
return ret;
219
215
}
220
216
221
217
void *kexec_file_add_components(struct kimage *image,
···
329
321
arch_kexec_do_relocs(r_type, loc, val, addr);
330
322
}
331
323
return 0;
324
+
}
325
+
326
+
int arch_kimage_file_post_load_cleanup(struct kimage *image)
327
+
{
328
+
vfree(image->arch.ipl_buf);
329
+
image->arch.ipl_buf = NULL;
330
+
331
+
return kexec_image_post_load_cleanup_default(image);
332
332
}
+5
-17
arch/s390/kernel/setup.c
+5
-17
arch/s390/kernel/setup.c
···
606
606
607
607
static void __init setup_memory_end(void)
608
608
{
609
-
memblock_remove(ident_map_size, ULONG_MAX);
609
+
memblock_remove(ident_map_size, PHYS_ADDR_MAX - ident_map_size);
610
610
max_pfn = max_low_pfn = PFN_DOWN(ident_map_size);
611
611
pr_notice("The maximum memory size is %luMB\n", ident_map_size >> 20);
612
612
}
···
636
636
};
637
637
638
638
#endif
639
-
640
-
/*
641
-
* Make sure that the area above identity mapping is protected
642
-
*/
643
-
static void __init reserve_above_ident_map(void)
644
-
{
645
-
memblock_reserve(ident_map_size, ULONG_MAX);
646
-
}
647
639
648
640
/*
649
641
* Reserve memory for kdump kernel to be loaded with kexec
···
777
785
}
778
786
memblock_set_bottom_up(false);
779
787
memblock_set_node(0, ULONG_MAX, &memblock.memory, 0);
780
-
memblock_dump_all();
781
788
}
782
789
783
790
/*
···
817
826
storage_key_init_range(start, end);
818
827
819
828
psw_set_key(PAGE_DEFAULT_KEY);
820
-
821
-
/* Only cosmetics */
822
-
memblock_enforce_memory_limit(memblock_end_of_DRAM());
823
829
}
824
830
825
831
static void __init relocate_amode31_section(void)
···
987
999
setup_control_program_code();
988
1000
989
1001
/* Do some memory reservations *before* memory is added to memblock */
990
-
reserve_above_ident_map();
991
1002
reserve_kernel();
992
1003
reserve_initrd();
993
1004
reserve_certificate_list();
994
1005
reserve_mem_detect_info();
1006
+
memblock_set_current_limit(ident_map_size);
995
1007
memblock_allow_resize();
996
1008
997
1009
/* Get information about *all* installed memory */
998
1010
memblock_add_mem_detect_info();
999
1011
1000
1012
free_mem_detect_info();
1013
+
setup_memory_end();
1014
+
memblock_dump_all();
1015
+
setup_memory();
1001
1016
1002
1017
relocate_amode31_section();
1003
1018
setup_cr();
1004
-
1005
1019
setup_uv();
1006
-
setup_memory_end();
1007
-
setup_memory();
1008
1020
dma_contiguous_reserve(ident_map_size);
1009
1021
vmcp_cma_reserve();
1010
1022
if (MACHINE_HAS_EDAT2)
+1
arch/s390/kernel/syscalls/syscall.tbl
+1
arch/s390/kernel/syscalls/syscall.tbl
+1
-1
arch/s390/kernel/vdso32/Makefile
+1
-1
arch/s390/kernel/vdso32/Makefile
···
22
22
KBUILD_CFLAGS_32 := $(filter-out -m64,$(KBUILD_CFLAGS))
23
23
KBUILD_CFLAGS_32 += -m31 -fPIC -shared -fno-common -fno-builtin
24
24
25
-
LDFLAGS_vdso32.so.dbg += -fPIC -shared -nostdlib -soname=linux-vdso32.so.1 \
25
+
LDFLAGS_vdso32.so.dbg += -fPIC -shared -soname=linux-vdso32.so.1 \
26
26
--hash-style=both --build-id=sha1 -melf_s390 -T
27
27
28
28
$(targets:%=$(obj)/%.dbg): KBUILD_CFLAGS = $(KBUILD_CFLAGS_32)
+4
-3
arch/s390/kernel/vdso64/Makefile
+4
-3
arch/s390/kernel/vdso64/Makefile
···
8
8
include $(srctree)/lib/vdso/Makefile
9
9
obj-vdso64 = vdso_user_wrapper.o note.o
10
10
obj-cvdso64 = vdso64_generic.o getcpu.o
11
-
CFLAGS_REMOVE_getcpu.o = -pg $(CC_FLAGS_FTRACE) $(CC_FLAGS_EXPOLINE)
12
-
CFLAGS_REMOVE_vdso64_generic.o = -pg $(CC_FLAGS_FTRACE) $(CC_FLAGS_EXPOLINE)
11
+
VDSO_CFLAGS_REMOVE := -pg $(CC_FLAGS_FTRACE) $(CC_FLAGS_EXPOLINE) $(CC_FLAGS_CHECK_STACK)
12
+
CFLAGS_REMOVE_getcpu.o = $(VDSO_CFLAGS_REMOVE)
13
+
CFLAGS_REMOVE_vdso64_generic.o = $(VDSO_CFLAGS_REMOVE)
13
14
14
15
# Build rules
15
16
···
26
25
27
26
KBUILD_CFLAGS_64 := $(filter-out -m64,$(KBUILD_CFLAGS))
28
27
KBUILD_CFLAGS_64 += -m64 -fPIC -shared -fno-common -fno-builtin
29
-
ldflags-y := -fPIC -shared -nostdlib -soname=linux-vdso64.so.1 \
28
+
ldflags-y := -fPIC -shared -soname=linux-vdso64.so.1 \
30
29
--hash-style=both --build-id=sha1 -T
31
30
32
31
$(targets:%=$(obj)/%.dbg): KBUILD_CFLAGS = $(KBUILD_CFLAGS_64)
+1
-1
arch/x86/Kconfig
+1
-1
arch/x86/Kconfig
···
193
193
select HAVE_DYNAMIC_FTRACE_WITH_ARGS if X86_64
194
194
select HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
195
195
select HAVE_SAMPLE_FTRACE_DIRECT if X86_64
196
-
select HAVE_SAMPLE_FTRACE_MULTI_DIRECT if X86_64
196
+
select HAVE_SAMPLE_FTRACE_DIRECT_MULTI if X86_64
197
197
select HAVE_EBPF_JIT
198
198
select HAVE_EFFICIENT_UNALIGNED_ACCESS
199
199
select HAVE_EISA
+38
-38
drivers/s390/block/dasd_devmap.c
+38
-38
drivers/s390/block/dasd_devmap.c
···
731
731
ff_flag = (devmap->features & DASD_FEATURE_FAILFAST) != 0;
732
732
else
733
733
ff_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_FAILFAST) != 0;
734
-
return snprintf(buf, PAGE_SIZE, ff_flag ? "1\n" : "0\n");
734
+
return sysfs_emit(buf, ff_flag ? "1\n" : "0\n");
735
735
}
736
736
737
737
static ssize_t dasd_ff_store(struct device *dev, struct device_attribute *attr,
···
773
773
spin_unlock(&dasd_devmap_lock);
774
774
775
775
out:
776
-
return snprintf(buf, PAGE_SIZE, ro_flag ? "1\n" : "0\n");
776
+
return sysfs_emit(buf, ro_flag ? "1\n" : "0\n");
777
777
}
778
778
779
779
static ssize_t
···
834
834
erplog = (devmap->features & DASD_FEATURE_ERPLOG) != 0;
835
835
else
836
836
erplog = (DASD_FEATURE_DEFAULT & DASD_FEATURE_ERPLOG) != 0;
837
-
return snprintf(buf, PAGE_SIZE, erplog ? "1\n" : "0\n");
837
+
return sysfs_emit(buf, erplog ? "1\n" : "0\n");
838
838
}
839
839
840
840
static ssize_t
···
1033
1033
dasd_put_device(device);
1034
1034
goto out;
1035
1035
} else {
1036
-
len = snprintf(buf, PAGE_SIZE, "%s\n",
1037
-
device->discipline->name);
1036
+
len = sysfs_emit(buf, "%s\n",
1037
+
device->discipline->name);
1038
1038
dasd_put_device(device);
1039
1039
return len;
1040
1040
}
1041
1041
out:
1042
-
len = snprintf(buf, PAGE_SIZE, "none\n");
1042
+
len = sysfs_emit(buf, "none\n");
1043
1043
return len;
1044
1044
}
1045
1045
···
1056
1056
if (!IS_ERR(device)) {
1057
1057
switch (device->state) {
1058
1058
case DASD_STATE_NEW:
1059
-
len = snprintf(buf, PAGE_SIZE, "new\n");
1059
+
len = sysfs_emit(buf, "new\n");
1060
1060
break;
1061
1061
case DASD_STATE_KNOWN:
1062
-
len = snprintf(buf, PAGE_SIZE, "detected\n");
1062
+
len = sysfs_emit(buf, "detected\n");
1063
1063
break;
1064
1064
case DASD_STATE_BASIC:
1065
-
len = snprintf(buf, PAGE_SIZE, "basic\n");
1065
+
len = sysfs_emit(buf, "basic\n");
1066
1066
break;
1067
1067
case DASD_STATE_UNFMT:
1068
-
len = snprintf(buf, PAGE_SIZE, "unformatted\n");
1068
+
len = sysfs_emit(buf, "unformatted\n");
1069
1069
break;
1070
1070
case DASD_STATE_READY:
1071
-
len = snprintf(buf, PAGE_SIZE, "ready\n");
1071
+
len = sysfs_emit(buf, "ready\n");
1072
1072
break;
1073
1073
case DASD_STATE_ONLINE:
1074
-
len = snprintf(buf, PAGE_SIZE, "online\n");
1074
+
len = sysfs_emit(buf, "online\n");
1075
1075
break;
1076
1076
default:
1077
-
len = snprintf(buf, PAGE_SIZE, "no stat\n");
1077
+
len = sysfs_emit(buf, "no stat\n");
1078
1078
break;
1079
1079
}
1080
1080
dasd_put_device(device);
1081
1081
} else
1082
-
len = snprintf(buf, PAGE_SIZE, "unknown\n");
1082
+
len = sysfs_emit(buf, "unknown\n");
1083
1083
return len;
1084
1084
}
1085
1085
···
1120
1120
device = dasd_device_from_cdev(to_ccwdev(dev));
1121
1121
vendor = "";
1122
1122
if (IS_ERR(device))
1123
-
return snprintf(buf, PAGE_SIZE, "%s\n", vendor);
1123
+
return sysfs_emit(buf, "%s\n", vendor);
1124
1124
1125
1125
if (device->discipline && device->discipline->get_uid &&
1126
1126
!device->discipline->get_uid(device, &uid))
···
1128
1128
1129
1129
dasd_put_device(device);
1130
1130
1131
-
return snprintf(buf, PAGE_SIZE, "%s\n", vendor);
1131
+
return sysfs_emit(buf, "%s\n", vendor);
1132
1132
}
1133
1133
1134
1134
static DEVICE_ATTR(vendor, 0444, dasd_vendor_show, NULL);
···
1148
1148
device = dasd_device_from_cdev(to_ccwdev(dev));
1149
1149
uid_string[0] = 0;
1150
1150
if (IS_ERR(device))
1151
-
return snprintf(buf, PAGE_SIZE, "%s\n", uid_string);
1151
+
return sysfs_emit(buf, "%s\n", uid_string);
1152
1152
1153
1153
if (device->discipline && device->discipline->get_uid &&
1154
1154
!device->discipline->get_uid(device, &uid)) {
···
1183
1183
}
1184
1184
dasd_put_device(device);
1185
1185
1186
-
return snprintf(buf, PAGE_SIZE, "%s\n", uid_string);
1186
+
return sysfs_emit(buf, "%s\n", uid_string);
1187
1187
}
1188
1188
static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL);
1189
1189
···
1201
1201
eer_flag = dasd_eer_enabled(devmap->device);
1202
1202
else
1203
1203
eer_flag = 0;
1204
-
return snprintf(buf, PAGE_SIZE, eer_flag ? "1\n" : "0\n");
1204
+
return sysfs_emit(buf, eer_flag ? "1\n" : "0\n");
1205
1205
}
1206
1206
1207
1207
static ssize_t
···
1243
1243
device = dasd_device_from_cdev(to_ccwdev(dev));
1244
1244
if (IS_ERR(device))
1245
1245
return -ENODEV;
1246
-
len = snprintf(buf, PAGE_SIZE, "%lu\n", device->default_expires);
1246
+
len = sysfs_emit(buf, "%lu\n", device->default_expires);
1247
1247
dasd_put_device(device);
1248
1248
return len;
1249
1249
}
···
1283
1283
device = dasd_device_from_cdev(to_ccwdev(dev));
1284
1284
if (IS_ERR(device))
1285
1285
return -ENODEV;
1286
-
len = snprintf(buf, PAGE_SIZE, "%lu\n", device->default_retries);
1286
+
len = sysfs_emit(buf, "%lu\n", device->default_retries);
1287
1287
dasd_put_device(device);
1288
1288
return len;
1289
1289
}
···
1324
1324
device = dasd_device_from_cdev(to_ccwdev(dev));
1325
1325
if (IS_ERR(device))
1326
1326
return -ENODEV;
1327
-
len = snprintf(buf, PAGE_SIZE, "%lu\n", device->blk_timeout);
1327
+
len = sysfs_emit(buf, "%lu\n", device->blk_timeout);
1328
1328
dasd_put_device(device);
1329
1329
return len;
1330
1330
}
···
1398
1398
return -ENODEV;
1399
1399
if (!device->discipline || !device->discipline->hpf_enabled) {
1400
1400
dasd_put_device(device);
1401
-
return snprintf(buf, PAGE_SIZE, "%d\n", dasd_nofcx);
1401
+
return sysfs_emit(buf, "%d\n", dasd_nofcx);
1402
1402
}
1403
1403
hpf = device->discipline->hpf_enabled(device);
1404
1404
dasd_put_device(device);
1405
-
return snprintf(buf, PAGE_SIZE, "%d\n", hpf);
1405
+
return sysfs_emit(buf, "%d\n", hpf);
1406
1406
}
1407
1407
1408
1408
static DEVICE_ATTR(hpf, 0444, dasd_hpf_show, NULL);
···
1416
1416
1417
1417
devmap = dasd_find_busid(dev_name(dev));
1418
1418
if (IS_ERR(devmap)) {
1419
-
rc = snprintf(buf, PAGE_SIZE, "ignore\n");
1419
+
rc = sysfs_emit(buf, "ignore\n");
1420
1420
} else {
1421
1421
spin_lock(&dasd_devmap_lock);
1422
1422
if (devmap->features & DASD_FEATURE_FAILONSLCK)
1423
-
rc = snprintf(buf, PAGE_SIZE, "fail\n");
1423
+
rc = sysfs_emit(buf, "fail\n");
1424
1424
else
1425
-
rc = snprintf(buf, PAGE_SIZE, "ignore\n");
1425
+
rc = sysfs_emit(buf, "ignore\n");
1426
1426
spin_unlock(&dasd_devmap_lock);
1427
1427
}
1428
1428
return rc;
···
1457
1457
1458
1458
device = dasd_device_from_cdev(to_ccwdev(dev));
1459
1459
if (IS_ERR(device))
1460
-
return snprintf(buf, PAGE_SIZE, "none\n");
1460
+
return sysfs_emit(buf, "none\n");
1461
1461
1462
1462
if (test_bit(DASD_FLAG_IS_RESERVED, &device->flags))
1463
-
rc = snprintf(buf, PAGE_SIZE, "reserved\n");
1463
+
rc = sysfs_emit(buf, "reserved\n");
1464
1464
else if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags))
1465
-
rc = snprintf(buf, PAGE_SIZE, "lost\n");
1465
+
rc = sysfs_emit(buf, "lost\n");
1466
1466
else
1467
-
rc = snprintf(buf, PAGE_SIZE, "none\n");
1467
+
rc = sysfs_emit(buf, "none\n");
1468
1468
dasd_put_device(device);
1469
1469
return rc;
1470
1470
}
···
1531
1531
device = dasd_device_from_cdev(to_ccwdev(dev));
1532
1532
if (IS_ERR(device))
1533
1533
return -ENODEV;
1534
-
len = snprintf(buf, PAGE_SIZE, "%lu\n", device->path_thrhld);
1534
+
len = sysfs_emit(buf, "%lu\n", device->path_thrhld);
1535
1535
dasd_put_device(device);
1536
1536
return len;
1537
1537
}
···
1578
1578
else
1579
1579
flag = (DASD_FEATURE_DEFAULT &
1580
1580
DASD_FEATURE_PATH_AUTODISABLE) != 0;
1581
-
return snprintf(buf, PAGE_SIZE, flag ? "1\n" : "0\n");
1581
+
return sysfs_emit(buf, flag ? "1\n" : "0\n");
1582
1582
}
1583
1583
1584
1584
static ssize_t
···
1616
1616
device = dasd_device_from_cdev(to_ccwdev(dev));
1617
1617
if (IS_ERR(device))
1618
1618
return -ENODEV;
1619
-
len = snprintf(buf, PAGE_SIZE, "%lu\n", device->path_interval);
1619
+
len = sysfs_emit(buf, "%lu\n", device->path_interval);
1620
1620
dasd_put_device(device);
1621
1621
return len;
1622
1622
}
···
1662
1662
return -ENODEV;
1663
1663
fc_sec = dasd_path_get_fcs_device(device);
1664
1664
if (fc_sec == -EINVAL)
1665
-
rc = snprintf(buf, PAGE_SIZE, "Inconsistent\n");
1665
+
rc = sysfs_emit(buf, "Inconsistent\n");
1666
1666
else
1667
-
rc = snprintf(buf, PAGE_SIZE, "%s\n", dasd_path_get_fcs_str(fc_sec));
1667
+
rc = sysfs_emit(buf, "%s\n", dasd_path_get_fcs_str(fc_sec));
1668
1668
dasd_put_device(device);
1669
1669
1670
1670
return rc;
···
1677
1677
struct dasd_path *path = to_dasd_path(kobj);
1678
1678
unsigned int fc_sec = path->fc_security;
1679
1679
1680
-
return snprintf(buf, PAGE_SIZE, "%s\n", dasd_path_get_fcs_str(fc_sec));
1680
+
return sysfs_emit(buf, "%s\n", dasd_path_get_fcs_str(fc_sec));
1681
1681
}
1682
1682
1683
1683
static struct kobj_attribute path_fcs_attribute =
···
1698
1698
val = _func(device); \
1699
1699
dasd_put_device(device); \
1700
1700
\
1701
-
return snprintf(buf, PAGE_SIZE, "%d\n", val); \
1701
+
return sysfs_emit(buf, "%d\n", val); \
1702
1702
} \
1703
1703
static DEVICE_ATTR(_name, 0444, dasd_##_name##_show, NULL); \
1704
1704
+6
-6
drivers/s390/char/raw3270.c
+6
-6
drivers/s390/char/raw3270.c
···
1047
1047
static ssize_t
1048
1048
raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf)
1049
1049
{
1050
-
return snprintf(buf, PAGE_SIZE, "%i\n",
1051
-
((struct raw3270 *) dev_get_drvdata(dev))->model);
1050
+
return sysfs_emit(buf, "%i\n",
1051
+
((struct raw3270 *)dev_get_drvdata(dev))->model);
1052
1052
}
1053
1053
static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);
1054
1054
1055
1055
static ssize_t
1056
1056
raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
1057
1057
{
1058
-
return snprintf(buf, PAGE_SIZE, "%i\n",
1059
-
((struct raw3270 *) dev_get_drvdata(dev))->rows);
1058
+
return sysfs_emit(buf, "%i\n",
1059
+
((struct raw3270 *)dev_get_drvdata(dev))->rows);
1060
1060
}
1061
1061
static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);
1062
1062
1063
1063
static ssize_t
1064
1064
raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
1065
1065
{
1066
-
return snprintf(buf, PAGE_SIZE, "%i\n",
1067
-
((struct raw3270 *) dev_get_drvdata(dev))->cols);
1066
+
return sysfs_emit(buf, "%i\n",
1067
+
((struct raw3270 *)dev_get_drvdata(dev))->cols);
1068
1068
}
1069
1069
static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);
1070
1070
+1
-1
drivers/s390/cio/chp.c
+1
-1
drivers/s390/cio/chp.c
+10
-1
samples/Kconfig
+10
-1
samples/Kconfig
···
31
31
This builds an ftrace direct function example
32
32
that hooks to wake_up_process and prints the parameters.
33
33
34
+
config SAMPLE_FTRACE_DIRECT_MULTI
35
+
tristate "Build register_ftrace_direct_multi() example"
36
+
depends on DYNAMIC_FTRACE_WITH_DIRECT_CALLS && m
37
+
depends on HAVE_SAMPLE_FTRACE_DIRECT_MULTI
38
+
help
39
+
This builds an ftrace direct function example
40
+
that hooks to wake_up_process and schedule, and prints
41
+
the function addresses.
42
+
34
43
config SAMPLE_TRACE_ARRAY
35
44
tristate "Build sample module for kernel access to Ftrace instancess"
36
45
depends on EVENT_TRACING && m
···
246
237
config HAVE_SAMPLE_FTRACE_DIRECT
247
238
bool
248
239
249
-
config HAVE_SAMPLE_FTRACE_MULTI_DIRECT
240
+
config HAVE_SAMPLE_FTRACE_DIRECT_MULTI
250
241
bool
+1
-1
samples/Makefile
+1
-1
samples/Makefile
···
22
22
obj-$(CONFIG_SAMPLE_TRACE_EVENTS) += trace_events/
23
23
obj-$(CONFIG_SAMPLE_TRACE_PRINTK) += trace_printk/
24
24
obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace/
25
-
obj-$(CONFIG_SAMPLE_FTRACE_MULTI_DIRECT) += ftrace/
25
+
obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace/
26
26
obj-$(CONFIG_SAMPLE_TRACE_ARRAY) += ftrace/
27
27
subdir-$(CONFIG_SAMPLE_UHID) += uhid
28
28
obj-$(CONFIG_VIDEO_PCI_SKELETON) += v4l/
+1
-1
samples/ftrace/Makefile
+1
-1
samples/ftrace/Makefile
···
3
3
obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct.o
4
4
obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-too.o
5
5
obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-modify.o
6
-
obj-$(CONFIG_SAMPLE_FTRACE_MULTI_DIRECT) += ftrace-direct-multi.o
6
+
obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace-direct-multi.o
7
7
8
8
CFLAGS_sample-trace-array.o := -I$(src)
9
9
obj-$(CONFIG_SAMPLE_TRACE_ARRAY) += sample-trace-array.o
+30
samples/ftrace/ftrace-direct-multi.c
+30
samples/ftrace/ftrace-direct-multi.c
···
4
4
#include <linux/mm.h> /* for handle_mm_fault() */
5
5
#include <linux/ftrace.h>
6
6
#include <linux/sched/stat.h>
7
+
#include <asm/asm-offsets.h>
7
8
8
9
extern void my_direct_func(unsigned long ip);
9
10
···
14
13
}
15
14
16
15
extern void my_tramp(void *);
16
+
17
+
#ifdef CONFIG_X86_64
17
18
18
19
asm (
19
20
" .pushsection .text, \"ax\", @progbits\n"
···
33
30
" .size my_tramp, .-my_tramp\n"
34
31
" .popsection\n"
35
32
);
33
+
34
+
#endif /* CONFIG_X86_64 */
35
+
36
+
#ifdef CONFIG_S390
37
+
38
+
asm (
39
+
" .pushsection .text, \"ax\", @progbits\n"
40
+
" .type my_tramp, @function\n"
41
+
" .globl my_tramp\n"
42
+
" my_tramp:"
43
+
" lgr %r1,%r15\n"
44
+
" stmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
45
+
" stg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
46
+
" aghi %r15,"__stringify(-STACK_FRAME_OVERHEAD)"\n"
47
+
" stg %r1,"__stringify(__SF_BACKCHAIN)"(%r15)\n"
48
+
" lgr %r2,%r0\n"
49
+
" brasl %r14,my_direct_func\n"
50
+
" aghi %r15,"__stringify(STACK_FRAME_OVERHEAD)"\n"
51
+
" lmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
52
+
" lg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
53
+
" lgr %r1,%r0\n"
54
+
" br %r1\n"
55
+
" .size my_tramp, .-my_tramp\n"
56
+
" .popsection\n"
57
+
);
58
+
59
+
#endif /* CONFIG_S390 */
36
60
37
61
static struct ftrace_ops direct;
38
62