Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 's390-5.3-3' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux
Pull s390 updates from Heiko Carstens:
- Add ABI to kernel image file which allows e.g. the file utility to
figure out the kernel version.
- Wire up clone3 system call.
- Add support for kasan bitops instrumentation.
- uapi header cleanup: use __u{16,32,64} instead of uint{16,32,64}_t.
- Provide proper ARCH_ZONE_DMA_BITS so the s390 DMA zone is correctly
defined with 2 GB instead of the default value of 1 MB.
- Farhan Ali leaves the group of vfio-ccw maintainers.
- Various small vfio-ccw fixes.
- Add missing locking for airq_areas array in virtio code.
- Minor qdio improvements.
* tag 's390-5.3-3' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux:
MAINTAINERS: vfio-ccw: Remove myself as the maintainer
s390/mm: use shared variables for sysctl range check
virtio/s390: fix race on airq_areas[]
s390/dma: provide proper ARCH_ZONE_DMA_BITS value
s390/kasan: add bitops instrumentation
s390/bitops: make test functions return bool
s390: wire up clone3 system call
kbuild: enable arch/s390/include/uapi/asm/zcrypt.h for uapi header test
s390: use __u{16,32,64} instead of uint{16,32,64}_t in uapi header
s390/hypfs: fix a typo in the name of a function
s390/qdio: restrict QAOB usage to IQD unicast queues
s390/qdio: add sanity checks to the fast-requeue path
s390: enable detection of kernel version from bzImage
Documentation: fix vfio-ccw doc
vfio-ccw: Update documentation for csch/hsch
vfio-ccw: Don't call cp_free if we are processing a channel program
vfio-ccw: Set pa_nr to 0 if memory allocation fails for pa_iova_pfn
vfio-ccw: Fix memory leak and don't call cp_free in cp_init
vfio-ccw: Fix misleading comment when setting orb.cmd.c64
+140
-92
+28
-3
Documentation/s390/vfio-ccw.rst
+28
-3
Documentation/s390/vfio-ccw.rst
···
180
180
add it to an iommu_group and a vfio_group. Then we could pass through
181
181
the mdev to a guest.
182
182
183
+
184
+
VFIO-CCW Regions
185
+
----------------
186
+
187
+
The vfio-ccw driver exposes MMIO regions to accept requests from and return
188
+
results to userspace.
189
+
183
190
vfio-ccw I/O region
184
191
-------------------
185
192
···
211
204
irb_area stores the I/O result.
212
205
213
206
ret_code stores a return code for each access of the region.
207
+
208
+
This region is always available.
209
+
210
+
vfio-ccw cmd region
211
+
-------------------
212
+
213
+
The vfio-ccw cmd region is used to accept asynchronous instructions
214
+
from userspace::
215
+
216
+
#define VFIO_CCW_ASYNC_CMD_HSCH (1 << 0)
217
+
#define VFIO_CCW_ASYNC_CMD_CSCH (1 << 1)
218
+
struct ccw_cmd_region {
219
+
__u32 command;
220
+
__u32 ret_code;
221
+
} __packed;
222
+
223
+
This region is exposed via region type VFIO_REGION_SUBTYPE_CCW_ASYNC_CMD.
224
+
225
+
Currently, CLEAR SUBCHANNEL and HALT SUBCHANNEL use this region.
214
226
215
227
vfio-ccw operation details
216
228
--------------------------
···
332
306
through DASD/ECKD device online in a guest now and use it as a block
333
307
device.
334
308
335
-
While the current code allows the guest to start channel programs via
336
-
START SUBCHANNEL, support for HALT SUBCHANNEL or CLEAR SUBCHANNEL is
337
-
not yet implemented.
309
+
The current code allows the guest to start channel programs via
310
+
START SUBCHANNEL, and to issue HALT SUBCHANNEL and CLEAR SUBCHANNEL.
338
311
339
312
vfio-ccw supports classic (command mode) channel I/O only. Transport
340
313
mode (HPF) is not supported.
-1
MAINTAINERS
-1
MAINTAINERS
+1
-1
arch/s390/boot/Makefile
+1
-1
arch/s390/boot/Makefile
···
36
36
37
37
obj-y := head.o als.o startup.o mem_detect.o ipl_parm.o ipl_report.o
38
38
obj-y += string.o ebcdic.o sclp_early_core.o mem.o ipl_vmparm.o cmdline.o
39
-
obj-y += ctype.o text_dma.o
39
+
obj-y += version.o ctype.o text_dma.o
40
40
obj-$(CONFIG_PROTECTED_VIRTUALIZATION_GUEST) += uv.o
41
41
obj-$(CONFIG_RELOCATABLE) += machine_kexec_reloc.o
42
42
obj-$(CONFIG_RANDOMIZE_BASE) += kaslr.o
+1
arch/s390/boot/boot.h
+1
arch/s390/boot/boot.h
+1
arch/s390/boot/head.S
+1
arch/s390/boot/head.S
+7
arch/s390/boot/version.c
+7
arch/s390/boot/version.c
+2
-2
arch/s390/hypfs/hypfs_vm.c
+2
-2
arch/s390/hypfs/hypfs_vm.c
···
118
118
return PTR_ERR(rc); \
119
119
} while(0)
120
120
121
-
static int hpyfs_vm_create_guest(struct dentry *systems_dir,
121
+
static int hypfs_vm_create_guest(struct dentry *systems_dir,
122
122
struct diag2fc_data *data)
123
123
{
124
124
char guest_name[NAME_LEN + 1] = {};
···
219
219
}
220
220
221
221
for (i = 0; i < count; i++) {
222
-
rc = hpyfs_vm_create_guest(dir, &(data[i]));
222
+
rc = hypfs_vm_create_guest(dir, &(data[i]));
223
223
if (rc)
224
224
goto failed;
225
225
}
+40
-33
arch/s390/include/asm/bitops.h
+40
-33
arch/s390/include/asm/bitops.h
···
35
35
36
36
#include <linux/typecheck.h>
37
37
#include <linux/compiler.h>
38
+
#include <linux/types.h>
38
39
#include <asm/atomic_ops.h>
39
40
#include <asm/barrier.h>
40
41
···
56
55
return ((unsigned char *)ptr) + ((nr ^ (BITS_PER_LONG - 8)) >> 3);
57
56
}
58
57
59
-
static inline void set_bit(unsigned long nr, volatile unsigned long *ptr)
58
+
static inline void arch_set_bit(unsigned long nr, volatile unsigned long *ptr)
60
59
{
61
60
unsigned long *addr = __bitops_word(nr, ptr);
62
61
unsigned long mask;
···
77
76
__atomic64_or(mask, (long *)addr);
78
77
}
79
78
80
-
static inline void clear_bit(unsigned long nr, volatile unsigned long *ptr)
79
+
static inline void arch_clear_bit(unsigned long nr, volatile unsigned long *ptr)
81
80
{
82
81
unsigned long *addr = __bitops_word(nr, ptr);
83
82
unsigned long mask;
···
98
97
__atomic64_and(mask, (long *)addr);
99
98
}
100
99
101
-
static inline void change_bit(unsigned long nr, volatile unsigned long *ptr)
100
+
static inline void arch_change_bit(unsigned long nr,
101
+
volatile unsigned long *ptr)
102
102
{
103
103
unsigned long *addr = __bitops_word(nr, ptr);
104
104
unsigned long mask;
···
120
118
__atomic64_xor(mask, (long *)addr);
121
119
}
122
120
123
-
static inline int
124
-
test_and_set_bit(unsigned long nr, volatile unsigned long *ptr)
121
+
static inline bool arch_test_and_set_bit(unsigned long nr,
122
+
volatile unsigned long *ptr)
125
123
{
126
124
unsigned long *addr = __bitops_word(nr, ptr);
127
125
unsigned long old, mask;
···
131
129
return (old & mask) != 0;
132
130
}
133
131
134
-
static inline int
135
-
test_and_clear_bit(unsigned long nr, volatile unsigned long *ptr)
132
+
static inline bool arch_test_and_clear_bit(unsigned long nr,
133
+
volatile unsigned long *ptr)
136
134
{
137
135
unsigned long *addr = __bitops_word(nr, ptr);
138
136
unsigned long old, mask;
···
142
140
return (old & ~mask) != 0;
143
141
}
144
142
145
-
static inline int
146
-
test_and_change_bit(unsigned long nr, volatile unsigned long *ptr)
143
+
static inline bool arch_test_and_change_bit(unsigned long nr,
144
+
volatile unsigned long *ptr)
147
145
{
148
146
unsigned long *addr = __bitops_word(nr, ptr);
149
147
unsigned long old, mask;
···
153
151
return (old & mask) != 0;
154
152
}
155
153
156
-
static inline void __set_bit(unsigned long nr, volatile unsigned long *ptr)
154
+
static inline void arch___set_bit(unsigned long nr, volatile unsigned long *ptr)
157
155
{
158
156
unsigned char *addr = __bitops_byte(nr, ptr);
159
157
160
158
*addr |= 1 << (nr & 7);
161
159
}
162
160
163
-
static inline void
164
-
__clear_bit(unsigned long nr, volatile unsigned long *ptr)
161
+
static inline void arch___clear_bit(unsigned long nr,
162
+
volatile unsigned long *ptr)
165
163
{
166
164
unsigned char *addr = __bitops_byte(nr, ptr);
167
165
168
166
*addr &= ~(1 << (nr & 7));
169
167
}
170
168
171
-
static inline void __change_bit(unsigned long nr, volatile unsigned long *ptr)
169
+
static inline void arch___change_bit(unsigned long nr,
170
+
volatile unsigned long *ptr)
172
171
{
173
172
unsigned char *addr = __bitops_byte(nr, ptr);
174
173
175
174
*addr ^= 1 << (nr & 7);
176
175
}
177
176
178
-
static inline int
179
-
__test_and_set_bit(unsigned long nr, volatile unsigned long *ptr)
177
+
static inline bool arch___test_and_set_bit(unsigned long nr,
178
+
volatile unsigned long *ptr)
180
179
{
181
180
unsigned char *addr = __bitops_byte(nr, ptr);
182
181
unsigned char ch;
···
187
184
return (ch >> (nr & 7)) & 1;
188
185
}
189
186
190
-
static inline int
191
-
__test_and_clear_bit(unsigned long nr, volatile unsigned long *ptr)
187
+
static inline bool arch___test_and_clear_bit(unsigned long nr,
188
+
volatile unsigned long *ptr)
192
189
{
193
190
unsigned char *addr = __bitops_byte(nr, ptr);
194
191
unsigned char ch;
···
198
195
return (ch >> (nr & 7)) & 1;
199
196
}
200
197
201
-
static inline int
202
-
__test_and_change_bit(unsigned long nr, volatile unsigned long *ptr)
198
+
static inline bool arch___test_and_change_bit(unsigned long nr,
199
+
volatile unsigned long *ptr)
203
200
{
204
201
unsigned char *addr = __bitops_byte(nr, ptr);
205
202
unsigned char ch;
···
209
206
return (ch >> (nr & 7)) & 1;
210
207
}
211
208
212
-
static inline int test_bit(unsigned long nr, const volatile unsigned long *ptr)
209
+
static inline bool arch_test_bit(unsigned long nr,
210
+
const volatile unsigned long *ptr)
213
211
{
214
212
const volatile unsigned char *addr;
215
213
···
219
215
return (*addr >> (nr & 7)) & 1;
220
216
}
221
217
222
-
static inline int test_and_set_bit_lock(unsigned long nr,
223
-
volatile unsigned long *ptr)
218
+
static inline bool arch_test_and_set_bit_lock(unsigned long nr,
219
+
volatile unsigned long *ptr)
224
220
{
225
-
if (test_bit(nr, ptr))
221
+
if (arch_test_bit(nr, ptr))
226
222
return 1;
227
-
return test_and_set_bit(nr, ptr);
223
+
return arch_test_and_set_bit(nr, ptr);
228
224
}
229
225
230
-
static inline void clear_bit_unlock(unsigned long nr,
231
-
volatile unsigned long *ptr)
226
+
static inline void arch_clear_bit_unlock(unsigned long nr,
227
+
volatile unsigned long *ptr)
232
228
{
233
229
smp_mb__before_atomic();
234
-
clear_bit(nr, ptr);
230
+
arch_clear_bit(nr, ptr);
235
231
}
236
232
237
-
static inline void __clear_bit_unlock(unsigned long nr,
238
-
volatile unsigned long *ptr)
233
+
static inline void arch___clear_bit_unlock(unsigned long nr,
234
+
volatile unsigned long *ptr)
239
235
{
240
236
smp_mb();
241
-
__clear_bit(nr, ptr);
237
+
arch___clear_bit(nr, ptr);
242
238
}
239
+
240
+
#include <asm-generic/bitops-instrumented.h>
243
241
244
242
/*
245
243
* Functions which use MSB0 bit numbering.
···
267
261
return clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);
268
262
}
269
263
270
-
static inline int test_and_clear_bit_inv(unsigned long nr, volatile unsigned long *ptr)
264
+
static inline bool test_and_clear_bit_inv(unsigned long nr,
265
+
volatile unsigned long *ptr)
271
266
{
272
267
return test_and_clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);
273
268
}
···
283
276
return __clear_bit(nr ^ (BITS_PER_LONG - 1), ptr);
284
277
}
285
278
286
-
static inline int test_bit_inv(unsigned long nr,
287
-
const volatile unsigned long *ptr)
279
+
static inline bool test_bit_inv(unsigned long nr,
280
+
const volatile unsigned long *ptr)
288
281
{
289
282
return test_bit(nr ^ (BITS_PER_LONG - 1), ptr);
290
283
}
+2
arch/s390/include/asm/page.h
+2
arch/s390/include/asm/page.h
+3
-1
arch/s390/include/asm/setup.h
+3
-1
arch/s390/include/asm/setup.h
···
54
54
#define INITRD_SIZE_OFFSET 0x10410
55
55
#define OLDMEM_BASE_OFFSET 0x10418
56
56
#define OLDMEM_SIZE_OFFSET 0x10420
57
+
#define KERNEL_VERSION_OFFSET 0x10428
57
58
#define COMMAND_LINE_OFFSET 0x10480
58
59
59
60
#ifndef __ASSEMBLY__
···
75
74
unsigned long initrd_size; /* 0x10410 */
76
75
unsigned long oldmem_base; /* 0x10418 */
77
76
unsigned long oldmem_size; /* 0x10420 */
78
-
char pad1[0x10480 - 0x10428]; /* 0x10428 - 0x10480 */
77
+
unsigned long kernel_version; /* 0x10428 */
78
+
char pad1[0x10480 - 0x10430]; /* 0x10430 - 0x10480 */
79
79
char command_line[ARCH_COMMAND_LINE_SIZE]; /* 0x10480 */
80
80
};
81
81
+1
arch/s390/include/asm/unistd.h
+1
arch/s390/include/asm/unistd.h
+18
-17
arch/s390/include/uapi/asm/zcrypt.h
+18
-17
arch/s390/include/uapi/asm/zcrypt.h
···
20
20
21
21
#include <linux/ioctl.h>
22
22
#include <linux/compiler.h>
23
+
#include <linux/types.h>
23
24
24
25
/* Name of the zcrypt device driver. */
25
26
#define ZCRYPT_NAME "zcrypt"
···
161
160
* @payload_len: Payload length
162
161
*/
163
162
struct ep11_cprb {
164
-
uint16_t cprb_len;
163
+
__u16 cprb_len;
165
164
unsigned char cprb_ver_id;
166
165
unsigned char pad_000[2];
167
166
unsigned char flags;
168
167
unsigned char func_id[2];
169
-
uint32_t source_id;
170
-
uint32_t target_id;
171
-
uint32_t ret_code;
172
-
uint32_t reserved1;
173
-
uint32_t reserved2;
174
-
uint32_t payload_len;
168
+
__u32 source_id;
169
+
__u32 target_id;
170
+
__u32 ret_code;
171
+
__u32 reserved1;
172
+
__u32 reserved2;
173
+
__u32 payload_len;
175
174
} __attribute__((packed));
176
175
177
176
/**
···
180
179
* @dom_id: Usage domain id
181
180
*/
182
181
struct ep11_target_dev {
183
-
uint16_t ap_id;
184
-
uint16_t dom_id;
182
+
__u16 ap_id;
183
+
__u16 dom_id;
185
184
};
186
185
187
186
/**
···
196
195
* @resp: Addr to response block
197
196
*/
198
197
struct ep11_urb {
199
-
uint16_t targets_num;
200
-
uint64_t targets;
201
-
uint64_t weight;
202
-
uint64_t req_no;
203
-
uint64_t req_len;
204
-
uint64_t req;
205
-
uint64_t resp_len;
206
-
uint64_t resp;
198
+
__u16 targets_num;
199
+
__u64 targets;
200
+
__u64 weight;
201
+
__u64 req_no;
202
+
__u64 req_len;
203
+
__u64 req;
204
+
__u64 resp_len;
205
+
__u64 resp;
207
206
} __attribute__((packed));
208
207
209
208
/**
+1
-1
arch/s390/kernel/syscalls/syscall.tbl
+1
-1
arch/s390/kernel/syscalls/syscall.tbl
+2
-4
arch/s390/mm/pgalloc.c
+2
-4
arch/s390/mm/pgalloc.c
···
17
17
18
18
#ifdef CONFIG_PGSTE
19
19
20
-
static int page_table_allocate_pgste_min = 0;
21
-
static int page_table_allocate_pgste_max = 1;
22
20
int page_table_allocate_pgste = 0;
23
21
EXPORT_SYMBOL(page_table_allocate_pgste);
24
22
···
27
29
.maxlen = sizeof(int),
28
30
.mode = S_IRUGO | S_IWUSR,
29
31
.proc_handler = proc_dointvec_minmax,
30
-
.extra1 = &page_table_allocate_pgste_min,
31
-
.extra2 = &page_table_allocate_pgste_max,
32
+
.extra1 = SYSCTL_ZERO,
33
+
.extra2 = SYSCTL_ONE,
32
34
},
33
35
{ }
34
36
};
+11
-13
drivers/s390/cio/qdio_main.c
+11
-13
drivers/s390/cio/qdio_main.c
···
319
319
int retries = 0, cc;
320
320
unsigned long laob = 0;
321
321
322
-
WARN_ON_ONCE(aob && ((queue_type(q) != QDIO_IQDIO_QFMT) ||
323
-
!q->u.out.use_cq));
324
-
if (q->u.out.use_cq && aob != 0) {
322
+
if (aob) {
325
323
fc = QDIO_SIGA_WRITEQ;
326
324
laob = aob;
327
325
}
···
618
620
int bufnr)
619
621
{
620
622
unsigned long phys_aob = 0;
621
-
622
-
if (!q->use_cq)
623
-
return 0;
624
623
625
624
if (!q->aobs[bufnr]) {
626
625
struct qaob *aob = qdio_allocate_aob();
···
1303
1308
1304
1309
for_each_output_queue(irq_ptr, q, i) {
1305
1310
if (use_cq) {
1311
+
if (multicast_outbound(q))
1312
+
continue;
1306
1313
if (qdio_enable_async_operation(&q->u.out) < 0) {
1307
1314
use_cq = 0;
1308
1315
continue;
···
1550
1553
/* One SIGA-W per buffer required for unicast HSI */
1551
1554
WARN_ON_ONCE(count > 1 && !multicast_outbound(q));
1552
1555
1553
-
phys_aob = qdio_aob_for_buffer(&q->u.out, bufnr);
1556
+
if (q->u.out.use_cq)
1557
+
phys_aob = qdio_aob_for_buffer(&q->u.out, bufnr);
1554
1558
1555
1559
rc = qdio_kick_outbound_q(q, phys_aob);
1556
1560
} else if (need_siga_sync(q)) {
1557
1561
rc = qdio_siga_sync_q(q);
1562
+
} else if (count < QDIO_MAX_BUFFERS_PER_Q &&
1563
+
get_buf_state(q, prev_buf(bufnr), &state, 0) > 0 &&
1564
+
state == SLSB_CU_OUTPUT_PRIMED) {
1565
+
/* The previous buffer is not processed yet, tack on. */
1566
+
qperf_inc(q, fast_requeue);
1558
1567
} else {
1559
-
/* try to fast requeue buffers */
1560
-
get_buf_state(q, prev_buf(bufnr), &state, 0);
1561
-
if (state != SLSB_CU_OUTPUT_PRIMED)
1562
-
rc = qdio_kick_outbound_q(q, 0);
1563
-
else
1564
-
qperf_inc(q, fast_requeue);
1568
+
rc = qdio_kick_outbound_q(q, 0);
1565
1569
}
1566
1570
1567
1571
/* in case of SIGA errors we must process the error immediately */
+17
-11
drivers/s390/cio/vfio_ccw_cp.c
+17
-11
drivers/s390/cio/vfio_ccw_cp.c
···
72
72
sizeof(*pa->pa_iova_pfn) +
73
73
sizeof(*pa->pa_pfn),
74
74
GFP_KERNEL);
75
-
if (unlikely(!pa->pa_iova_pfn))
75
+
if (unlikely(!pa->pa_iova_pfn)) {
76
+
pa->pa_nr = 0;
76
77
return -ENOMEM;
78
+
}
77
79
pa->pa_pfn = pa->pa_iova_pfn + pa->pa_nr;
78
80
79
81
pa->pa_iova_pfn[0] = pa->pa_iova >> PAGE_SHIFT;
···
423
421
static int ccwchain_handle_ccw(u32 cda, struct channel_program *cp)
424
422
{
425
423
struct ccwchain *chain;
426
-
int len;
424
+
int len, ret;
427
425
428
426
/* Copy 2K (the most we support today) of possible CCWs */
429
427
len = copy_from_iova(cp->mdev, cp->guest_cp, cda,
···
450
448
memcpy(chain->ch_ccw, cp->guest_cp, len * sizeof(struct ccw1));
451
449
452
450
/* Loop for tics on this new chain. */
453
-
return ccwchain_loop_tic(chain, cp);
451
+
ret = ccwchain_loop_tic(chain, cp);
452
+
453
+
if (ret)
454
+
ccwchain_free(chain);
455
+
456
+
return ret;
454
457
}
455
458
456
459
/* Loop for TICs. */
···
649
642
650
643
/* Build a ccwchain for the first CCW segment */
651
644
ret = ccwchain_handle_ccw(orb->cmd.cpa, cp);
652
-
if (ret)
653
-
cp_free(cp);
654
645
655
-
/* It is safe to force: if not set but idals used
656
-
* ccwchain_calc_length returns an error.
657
-
*/
658
-
cp->orb.cmd.c64 = 1;
659
-
660
-
if (!ret)
646
+
if (!ret) {
661
647
cp->initialized = true;
648
+
649
+
/* It is safe to force: if it was not set but idals used
650
+
* ccwchain_calc_length would have returned an error.
651
+
*/
652
+
cp->orb.cmd.c64 = 1;
653
+
}
662
654
663
655
return ret;
664
656
}
+1
-1
drivers/s390/cio/vfio_ccw_drv.c
+1
-1
drivers/s390/cio/vfio_ccw_drv.c
···
88
88
(SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT));
89
89
if (scsw_is_solicited(&irb->scsw)) {
90
90
cp_update_scsw(&private->cp, &irb->scsw);
91
-
if (is_final)
91
+
if (is_final && private->state == VFIO_CCW_STATE_CP_PENDING)
92
92
cp_free(&private->cp);
93
93
}
94
94
mutex_lock(&private->io_mutex);
+4
drivers/s390/virtio/virtio_ccw.c
+4
drivers/s390/virtio/virtio_ccw.c
···
145
145
struct airq_iv *aiv;
146
146
};
147
147
static struct airq_info *airq_areas[MAX_AIRQ_AREAS];
148
+
static DEFINE_MUTEX(airq_areas_lock);
149
+
148
150
static u8 *summary_indicators;
149
151
150
152
static inline u8 *get_summary_indicator(struct airq_info *info)
···
267
265
unsigned long bit, flags;
268
266
269
267
for (i = 0; i < MAX_AIRQ_AREAS && !indicator_addr; i++) {
268
+
mutex_lock(&airq_areas_lock);
270
269
if (!airq_areas[i])
271
270
airq_areas[i] = new_airq_info(i);
272
271
info = airq_areas[i];
272
+
mutex_unlock(&airq_areas_lock);
273
273
if (!info)
274
274
return 0;
275
275
write_lock_irqsave(&info->lock, flags);