blob: 0b5622714c12c3bce64f23db9634ca38ee89c8e0 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Author(s)......: Carsten Otte <cotte@de.ibm.com>
4 * Rob M van der Heij <rvdheij@nl.ibm.com>
5 * Steven Shultz <shultzss@us.ibm.com>
6 * Bugreports.to..: <Linux390@de.ibm.com>
Heiko Carstensa53c8fa2012-07-20 11:15:04 +02007 * Copyright IBM Corp. 2002, 2004
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
9
Hongjie Yang93098bf2008-12-25 13:39:45 +010010#define KMSG_COMPONENT "extmem"
11#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/kernel.h>
14#include <linux/string.h>
15#include <linux/spinlock.h>
16#include <linux/list.h>
17#include <linux/slab.h>
Paul Gortmakerff24b072017-02-09 15:20:24 -050018#include <linux/export.h>
Mike Rapoport57c8a662018-10-30 15:09:49 -070019#include <linux/memblock.h>
Heiko Carstens36a2bd42006-12-04 15:40:38 +010020#include <linux/ctype.h>
Gerald Schaefer444f0e52007-02-05 21:17:11 +010021#include <linux/ioport.h>
Martin Schwidefsky1ec27722015-08-20 17:28:44 +020022#include <asm/diag.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <asm/page.h>
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010024#include <asm/pgtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <asm/ebcdic.h>
26#include <asm/errno.h>
27#include <asm/extmem.h>
28#include <asm/cpcmd.h>
Heiko Carstens36a2bd42006-12-04 15:40:38 +010029#include <asm/setup.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#define DCSS_PURGESEG 0x08
Hongjie Yangb2300b92008-10-10 21:33:21 +020032#define DCSS_LOADSHRX 0x20
33#define DCSS_LOADNSRX 0x24
34#define DCSS_FINDSEGX 0x2c
35#define DCSS_SEGEXTX 0x38
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#define DCSS_FINDSEGA 0x0c
37
38struct qrange {
Hongjie Yangb2300b92008-10-10 21:33:21 +020039 unsigned long start; /* last byte type */
40 unsigned long end; /* last byte reserved */
Linus Torvalds1da177e2005-04-16 15:20:36 -070041};
42
43struct qout64 {
Hongjie Yangb2300b92008-10-10 21:33:21 +020044 unsigned long segstart;
45 unsigned long segend;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 int segcnt;
47 int segrcnt;
48 struct qrange range[6];
49};
50
51struct qin64 {
52 char qopcode;
53 char rsrv1[3];
54 char qrcode;
55 char rsrv2[3];
56 char qname[8];
57 unsigned int qoutptr;
58 short int qoutlen;
59};
60
61struct dcss_segment {
62 struct list_head list;
63 char dcss_name[8];
Vasily Gorbik6b2ddf32018-06-17 00:30:43 +020064 char res_name[16];
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 unsigned long start_addr;
66 unsigned long end;
67 atomic_t ref_count;
68 int do_nonshared;
69 unsigned int vm_segtype;
70 struct qrange range[6];
71 int segcnt;
Gerald Schaefer444f0e52007-02-05 21:17:11 +010072 struct resource *res;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073};
74
Heiko Carstens09252e72006-12-04 15:40:51 +010075static DEFINE_MUTEX(dcss_lock);
Denis Chengc11ca972008-01-26 14:11:13 +010076static LIST_HEAD(dcss_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077static char *segtype_string[] = { "SW", "EW", "SR", "ER", "SN", "EN", "SC",
78 "EW/EN-MIXED" };
Gerald Schaeferca571142019-02-21 15:34:21 +010079static int loadshr_scode = DCSS_LOADSHRX;
80static int loadnsr_scode = DCSS_LOADNSRX;
81static int purgeseg_scode = DCSS_PURGESEG;
82static int segext_scode = DCSS_SEGEXTX;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Linus Torvalds1da177e2005-04-16 15:20:36 -070084/*
85 * Create the 8 bytes, ebcdic VM segment name from
86 * an ascii name.
87 */
Heiko Carstens4d284ca2007-02-05 21:18:53 +010088static void
Linus Torvalds1da177e2005-04-16 15:20:36 -070089dcss_mkname(char *name, char *dcss_name)
90{
91 int i;
92
93 for (i = 0; i < 8; i++) {
94 if (name[i] == '\0')
95 break;
96 dcss_name[i] = toupper(name[i]);
Heiko Carstens0b925152017-01-02 08:51:02 +010097 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 for (; i < 8; i++)
99 dcss_name[i] = ' ';
100 ASCEBC(dcss_name, 8);
101}
102
103
104/*
105 * search all segments in dcss_list, and return the one
106 * namend *name. If not found, return NULL.
107 */
108static struct dcss_segment *
109segment_by_name (char *name)
110{
111 char dcss_name[9];
112 struct list_head *l;
113 struct dcss_segment *tmp, *retval = NULL;
114
Heiko Carstens09252e72006-12-04 15:40:51 +0100115 BUG_ON(!mutex_is_locked(&dcss_lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 dcss_mkname (name, dcss_name);
117 list_for_each (l, &dcss_list) {
118 tmp = list_entry (l, struct dcss_segment, list);
119 if (memcmp(tmp->dcss_name, dcss_name, 8) == 0) {
120 retval = tmp;
121 break;
122 }
123 }
124 return retval;
125}
126
127
128/*
129 * Perform a function on a dcss segment.
130 */
131static inline int
Hongjie Yangb2300b92008-10-10 21:33:21 +0200132dcss_diag(int *func, void *parameter,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 unsigned long *ret1, unsigned long *ret2)
134{
135 unsigned long rx, ry;
136 int rc;
137
138 rx = (unsigned long) parameter;
Hongjie Yangb2300b92008-10-10 21:33:21 +0200139 ry = (unsigned long) *func;
140
Martin Schwidefsky1ec27722015-08-20 17:28:44 +0200141 diag_stat_inc(DIAG_STAT_X064);
Gerald Schaeferca571142019-02-21 15:34:21 +0100142 asm volatile(
143 " diag %0,%1,0x64\n"
144 " ipm %2\n"
145 " srl %2,28\n"
146 : "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 *ret1 = rx;
148 *ret2 = ry;
149 return rc;
150}
151
152static inline int
153dcss_diag_translate_rc (int vm_rc) {
154 if (vm_rc == 44)
155 return -ENOENT;
156 return -EIO;
157}
158
159
160/* do a diag to get info about a segment.
161 * fills start_address, end and vm_segtype fields
162 */
163static int
164query_segment_type (struct dcss_segment *seg)
165{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 unsigned long dummy, vmrc;
Heiko Carstensc2f0e8c2010-06-08 18:58:09 +0200167 int diag_cc, rc, i;
168 struct qout64 *qout;
169 struct qin64 *qin;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Heiko Carstensc2f0e8c2010-06-08 18:58:09 +0200171 qin = kmalloc(sizeof(*qin), GFP_KERNEL | GFP_DMA);
172 qout = kmalloc(sizeof(*qout), GFP_KERNEL | GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 if ((qin == NULL) || (qout == NULL)) {
174 rc = -ENOMEM;
175 goto out_free;
176 }
177
178 /* initialize diag input parameters */
179 qin->qopcode = DCSS_FINDSEGA;
180 qin->qoutptr = (unsigned long) qout;
181 qin->qoutlen = sizeof(struct qout64);
182 memcpy (qin->qname, seg->dcss_name, 8);
183
Hongjie Yangb2300b92008-10-10 21:33:21 +0200184 diag_cc = dcss_diag(&segext_scode, qin, &dummy, &vmrc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
Hongjie Yangb2300b92008-10-10 21:33:21 +0200186 if (diag_cc < 0) {
187 rc = diag_cc;
188 goto out_free;
189 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 if (diag_cc > 1) {
Joe Perchesbaebc702016-03-03 20:49:57 -0800191 pr_warn("Querying a DCSS type failed with rc=%ld\n", vmrc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 rc = dcss_diag_translate_rc (vmrc);
193 goto out_free;
194 }
195
196 if (qout->segcnt > 6) {
Heiko Carstensb8e660b2010-02-26 22:37:41 +0100197 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 goto out_free;
199 }
200
201 if (qout->segcnt == 1) {
202 seg->vm_segtype = qout->range[0].start & 0xff;
203 } else {
204 /* multi-part segment. only one type supported here:
205 - all parts are contiguous
206 - all parts are either EW or EN type
207 - maximum 6 parts allowed */
208 unsigned long start = qout->segstart >> PAGE_SHIFT;
209 for (i=0; i<qout->segcnt; i++) {
210 if (((qout->range[i].start & 0xff) != SEG_TYPE_EW) &&
211 ((qout->range[i].start & 0xff) != SEG_TYPE_EN)) {
Heiko Carstensb8e660b2010-02-26 22:37:41 +0100212 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 goto out_free;
214 }
215 if (start != qout->range[i].start >> PAGE_SHIFT) {
Heiko Carstensb8e660b2010-02-26 22:37:41 +0100216 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 goto out_free;
218 }
219 start = (qout->range[i].end >> PAGE_SHIFT) + 1;
220 }
221 seg->vm_segtype = SEG_TYPE_EWEN;
222 }
223
224 /* analyze diag output and update seg */
225 seg->start_addr = qout->segstart;
226 seg->end = qout->segend;
227
228 memcpy (seg->range, qout->range, 6*sizeof(struct qrange));
229 seg->segcnt = qout->segcnt;
230
231 rc = 0;
232
233 out_free:
Jesper Juhlb2325fe2005-11-07 01:01:35 -0800234 kfree(qin);
235 kfree(qout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 return rc;
237}
238
239/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 * get info about a segment
241 * possible return values:
242 * -ENOSYS : we are not running on VM
243 * -EIO : could not perform query diagnose
244 * -ENOENT : no such segment
Heiko Carstensb8e660b2010-02-26 22:37:41 +0100245 * -EOPNOTSUPP: multi-part segment cannot be used with linux
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 * -ENOMEM : out of memory
247 * 0 .. 6 : type of segment as defined in include/asm-s390/extmem.h
248 */
249int
250segment_type (char* name)
251{
252 int rc;
253 struct dcss_segment seg;
254
255 if (!MACHINE_IS_VM)
256 return -ENOSYS;
257
258 dcss_mkname(name, seg.dcss_name);
259 rc = query_segment_type (&seg);
260 if (rc < 0)
261 return rc;
262 return seg.vm_segtype;
263}
264
265/*
Hongjie Yangb2300b92008-10-10 21:33:21 +0200266 * check if segment collides with other segments that are currently loaded
267 * returns 1 if this is the case, 0 if no collision was found
268 */
269static int
270segment_overlaps_others (struct dcss_segment *seg)
271{
272 struct list_head *l;
273 struct dcss_segment *tmp;
274
275 BUG_ON(!mutex_is_locked(&dcss_lock));
276 list_for_each(l, &dcss_list) {
277 tmp = list_entry(l, struct dcss_segment, list);
278 if ((tmp->start_addr >> 20) > (seg->end >> 20))
279 continue;
280 if ((tmp->end >> 20) < (seg->start_addr >> 20))
281 continue;
282 if (seg == tmp)
283 continue;
284 return 1;
285 }
286 return 0;
287}
288
289/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 * real segment loading function, called from segment_load
291 */
292static int
293__segment_load (char *name, int do_nonshared, unsigned long *addr, unsigned long *end)
294{
Hongjie Yangb2300b92008-10-10 21:33:21 +0200295 unsigned long start_addr, end_addr, dummy;
Heiko Carstensc2f0e8c2010-06-08 18:58:09 +0200296 struct dcss_segment *seg;
297 int rc, diag_cc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Heiko Carstens89db4df2011-05-23 10:24:29 +0200299 start_addr = end_addr = 0;
Heiko Carstensc2f0e8c2010-06-08 18:58:09 +0200300 seg = kmalloc(sizeof(*seg), GFP_KERNEL | GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 if (seg == NULL) {
302 rc = -ENOMEM;
303 goto out;
304 }
305 dcss_mkname (name, seg->dcss_name);
306 rc = query_segment_type (seg);
307 if (rc < 0)
308 goto out_free;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100309
Gerald Schaeferca571142019-02-21 15:34:21 +0100310 if (segment_overlaps_others(seg)) {
311 rc = -EBUSY;
312 goto out_free;
Hongjie Yangb2300b92008-10-10 21:33:21 +0200313 }
314
Heiko Carstens17f34582008-04-30 13:38:47 +0200315 rc = vmem_add_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100316
Martin Schwidefskyca683052008-04-17 07:46:31 +0200317 if (rc)
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100318 goto out_free;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100319
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100320 seg->res = kzalloc(sizeof(struct resource), GFP_KERNEL);
321 if (seg->res == NULL) {
322 rc = -ENOMEM;
323 goto out_shared;
324 }
325 seg->res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
326 seg->res->start = seg->start_addr;
327 seg->res->end = seg->end;
328 memcpy(&seg->res_name, seg->dcss_name, 8);
329 EBCASC(seg->res_name, 8);
330 seg->res_name[8] = '\0';
Vasily Gorbik6b2ddf32018-06-17 00:30:43 +0200331 strlcat(seg->res_name, " (DCSS)", sizeof(seg->res_name));
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100332 seg->res->name = seg->res_name;
333 rc = seg->vm_segtype;
334 if (rc == SEG_TYPE_SC ||
335 ((rc == SEG_TYPE_SR || rc == SEG_TYPE_ER) && !do_nonshared))
336 seg->res->flags |= IORESOURCE_READONLY;
337 if (request_resource(&iomem_resource, seg->res)) {
338 rc = -EBUSY;
339 kfree(seg->res);
340 goto out_shared;
341 }
342
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 if (do_nonshared)
Hongjie Yangb2300b92008-10-10 21:33:21 +0200344 diag_cc = dcss_diag(&loadnsr_scode, seg->dcss_name,
345 &start_addr, &end_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 else
Hongjie Yangb2300b92008-10-10 21:33:21 +0200347 diag_cc = dcss_diag(&loadshr_scode, seg->dcss_name,
348 &start_addr, &end_addr);
349 if (diag_cc < 0) {
350 dcss_diag(&purgeseg_scode, seg->dcss_name,
351 &dummy, &dummy);
352 rc = diag_cc;
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100353 goto out_resource;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 }
Hongjie Yangb2300b92008-10-10 21:33:21 +0200355 if (diag_cc > 1) {
Joe Perchesbaebc702016-03-03 20:49:57 -0800356 pr_warn("Loading DCSS %s failed with rc=%ld\n", name, end_addr);
Hongjie Yangb2300b92008-10-10 21:33:21 +0200357 rc = dcss_diag_translate_rc(end_addr);
358 dcss_diag(&purgeseg_scode, seg->dcss_name,
359 &dummy, &dummy);
360 goto out_resource;
361 }
362 seg->start_addr = start_addr;
363 seg->end = end_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 seg->do_nonshared = do_nonshared;
365 atomic_set(&seg->ref_count, 1);
366 list_add(&seg->list, &dcss_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 *addr = seg->start_addr;
368 *end = seg->end;
369 if (do_nonshared)
Gerald Schaeferf1777622019-02-21 15:36:31 +0100370 pr_info("DCSS %s of range %px to %px and type %s loaded as "
Hongjie Yang93098bf2008-12-25 13:39:45 +0100371 "exclusive-writable\n", name, (void*) seg->start_addr,
372 (void*) seg->end, segtype_string[seg->vm_segtype]);
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100373 else {
Gerald Schaeferf1777622019-02-21 15:36:31 +0100374 pr_info("DCSS %s of range %px to %px and type %s loaded in "
Hongjie Yang93098bf2008-12-25 13:39:45 +0100375 "shared access mode\n", name, (void*) seg->start_addr,
376 (void*) seg->end, segtype_string[seg->vm_segtype]);
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 goto out;
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100379 out_resource:
380 release_resource(seg->res);
381 kfree(seg->res);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100382 out_shared:
Heiko Carstens17f34582008-04-30 13:38:47 +0200383 vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 out_free:
Jesper Juhlb2325fe2005-11-07 01:01:35 -0800385 kfree(seg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 out:
387 return rc;
388}
389
390/*
391 * this function loads a DCSS segment
392 * name : name of the DCSS
393 * do_nonshared : 0 indicates that the dcss should be shared with other linux images
394 * 1 indicates that the dcss should be exclusive for this linux image
395 * addr : will be filled with start address of the segment
396 * end : will be filled with end address of the segment
397 * return values:
398 * -ENOSYS : we are not running on VM
399 * -EIO : could not perform query or load diagnose
400 * -ENOENT : no such segment
Heiko Carstensb8e660b2010-02-26 22:37:41 +0100401 * -EOPNOTSUPP: multi-part segment cannot be used with linux
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 * -ENOSPC : segment cannot be used (overlaps with storage)
403 * -EBUSY : segment can temporarily not be used (overlaps with dcss)
404 * -ERANGE : segment cannot be used (exceeds kernel mapping range)
405 * -EPERM : segment is currently loaded with incompatible permissions
406 * -ENOMEM : out of memory
407 * 0 .. 6 : type of segment as defined in include/asm-s390/extmem.h
408 */
409int
410segment_load (char *name, int do_nonshared, unsigned long *addr,
411 unsigned long *end)
412{
413 struct dcss_segment *seg;
414 int rc;
415
416 if (!MACHINE_IS_VM)
417 return -ENOSYS;
418
Heiko Carstens09252e72006-12-04 15:40:51 +0100419 mutex_lock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 seg = segment_by_name (name);
421 if (seg == NULL)
422 rc = __segment_load (name, do_nonshared, addr, end);
423 else {
424 if (do_nonshared == seg->do_nonshared) {
425 atomic_inc(&seg->ref_count);
426 *addr = seg->start_addr;
427 *end = seg->end;
428 rc = seg->vm_segtype;
429 } else {
430 *addr = *end = 0;
431 rc = -EPERM;
432 }
433 }
Heiko Carstens09252e72006-12-04 15:40:51 +0100434 mutex_unlock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 return rc;
436}
437
438/*
439 * this function modifies the shared state of a DCSS segment. note that
440 * name : name of the DCSS
441 * do_nonshared : 0 indicates that the dcss should be shared with other linux images
442 * 1 indicates that the dcss should be exclusive for this linux image
443 * return values:
444 * -EIO : could not perform load diagnose (segment gone!)
445 * -ENOENT : no such segment (segment gone!)
446 * -EAGAIN : segment is in use by other exploiters, try later
447 * -EINVAL : no segment with the given name is currently loaded - name invalid
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100448 * -EBUSY : segment can temporarily not be used (overlaps with dcss)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 * 0 : operation succeeded
450 */
451int
452segment_modify_shared (char *name, int do_nonshared)
453{
454 struct dcss_segment *seg;
Hongjie Yangb2300b92008-10-10 21:33:21 +0200455 unsigned long start_addr, end_addr, dummy;
456 int rc, diag_cc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
Heiko Carstens89db4df2011-05-23 10:24:29 +0200458 start_addr = end_addr = 0;
Heiko Carstens09252e72006-12-04 15:40:51 +0100459 mutex_lock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 seg = segment_by_name (name);
461 if (seg == NULL) {
462 rc = -EINVAL;
463 goto out_unlock;
464 }
465 if (do_nonshared == seg->do_nonshared) {
Hongjie Yang93098bf2008-12-25 13:39:45 +0100466 pr_info("DCSS %s is already in the requested access "
467 "mode\n", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 rc = 0;
469 goto out_unlock;
470 }
471 if (atomic_read (&seg->ref_count) != 1) {
Joe Perchesbaebc702016-03-03 20:49:57 -0800472 pr_warn("DCSS %s is in use and cannot be reloaded\n", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 rc = -EAGAIN;
474 goto out_unlock;
475 }
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100476 release_resource(seg->res);
Hongjie Yangb2300b92008-10-10 21:33:21 +0200477 if (do_nonshared)
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100478 seg->res->flags &= ~IORESOURCE_READONLY;
Hongjie Yangb2300b92008-10-10 21:33:21 +0200479 else
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100480 if (seg->vm_segtype == SEG_TYPE_SR ||
481 seg->vm_segtype == SEG_TYPE_ER)
482 seg->res->flags |= IORESOURCE_READONLY;
Hongjie Yangb2300b92008-10-10 21:33:21 +0200483
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100484 if (request_resource(&iomem_resource, seg->res)) {
Joe Perchesbaebc702016-03-03 20:49:57 -0800485 pr_warn("DCSS %s overlaps with used memory resources and cannot be reloaded\n",
486 name);
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100487 rc = -EBUSY;
488 kfree(seg->res);
Hongjie Yangb2300b92008-10-10 21:33:21 +0200489 goto out_del_mem;
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100490 }
Hongjie Yangb2300b92008-10-10 21:33:21 +0200491
492 dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
493 if (do_nonshared)
494 diag_cc = dcss_diag(&loadnsr_scode, seg->dcss_name,
495 &start_addr, &end_addr);
496 else
497 diag_cc = dcss_diag(&loadshr_scode, seg->dcss_name,
498 &start_addr, &end_addr);
499 if (diag_cc < 0) {
500 rc = diag_cc;
501 goto out_del_res;
502 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 if (diag_cc > 1) {
Joe Perchesbaebc702016-03-03 20:49:57 -0800504 pr_warn("Reloading DCSS %s failed with rc=%ld\n",
505 name, end_addr);
Hongjie Yangb2300b92008-10-10 21:33:21 +0200506 rc = dcss_diag_translate_rc(end_addr);
507 goto out_del_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
Hongjie Yangb2300b92008-10-10 21:33:21 +0200509 seg->start_addr = start_addr;
510 seg->end = end_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 seg->do_nonshared = do_nonshared;
512 rc = 0;
513 goto out_unlock;
Hongjie Yangb2300b92008-10-10 21:33:21 +0200514 out_del_res:
515 release_resource(seg->res);
516 kfree(seg->res);
517 out_del_mem:
Heiko Carstens17f34582008-04-30 13:38:47 +0200518 vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 list_del(&seg->list);
Hongjie Yangb2300b92008-10-10 21:33:21 +0200520 dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
Jesper Juhlb2325fe2005-11-07 01:01:35 -0800521 kfree(seg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 out_unlock:
Heiko Carstens09252e72006-12-04 15:40:51 +0100523 mutex_unlock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return rc;
525}
526
527/*
528 * Decrease the use count of a DCSS segment and remove
529 * it from the address space if nobody is using it
530 * any longer.
531 */
532void
533segment_unload(char *name)
534{
535 unsigned long dummy;
536 struct dcss_segment *seg;
537
538 if (!MACHINE_IS_VM)
539 return;
540
Heiko Carstens09252e72006-12-04 15:40:51 +0100541 mutex_lock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 seg = segment_by_name (name);
543 if (seg == NULL) {
Hongjie Yang93098bf2008-12-25 13:39:45 +0100544 pr_err("Unloading unknown DCSS %s failed\n", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 goto out_unlock;
546 }
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100547 if (atomic_dec_return(&seg->ref_count) != 0)
548 goto out_unlock;
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100549 release_resource(seg->res);
550 kfree(seg->res);
Heiko Carstens17f34582008-04-30 13:38:47 +0200551 vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100552 list_del(&seg->list);
Hongjie Yangb2300b92008-10-10 21:33:21 +0200553 dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100554 kfree(seg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555out_unlock:
Heiko Carstens09252e72006-12-04 15:40:51 +0100556 mutex_unlock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557}
558
559/*
560 * save segment content permanently
561 */
562void
563segment_save(char *name)
564{
565 struct dcss_segment *seg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 char cmd1[160];
567 char cmd2[80];
Gerald Schaefer9b5dec12006-04-27 18:40:22 -0700568 int i, response;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 if (!MACHINE_IS_VM)
571 return;
572
Heiko Carstens09252e72006-12-04 15:40:51 +0100573 mutex_lock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 seg = segment_by_name (name);
575
576 if (seg == NULL) {
Hongjie Yang93098bf2008-12-25 13:39:45 +0100577 pr_err("Saving unknown DCSS %s failed\n", name);
Heiko Carstens6b4044b2006-12-04 15:40:20 +0100578 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 }
580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 sprintf(cmd1, "DEFSEG %s", name);
582 for (i=0; i<seg->segcnt; i++) {
Hongjie Yangb2300b92008-10-10 21:33:21 +0200583 sprintf(cmd1+strlen(cmd1), " %lX-%lX %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 seg->range[i].start >> PAGE_SHIFT,
585 seg->range[i].end >> PAGE_SHIFT,
586 segtype_string[seg->range[i].start & 0xff]);
587 }
588 sprintf(cmd2, "SAVESEG %s", name);
Gerald Schaefer9b5dec12006-04-27 18:40:22 -0700589 response = 0;
590 cpcmd(cmd1, NULL, 0, &response);
591 if (response) {
Hongjie Yang93098bf2008-12-25 13:39:45 +0100592 pr_err("Saving a DCSS failed with DEFSEG response code "
593 "%i\n", response);
Gerald Schaefer9b5dec12006-04-27 18:40:22 -0700594 goto out;
595 }
596 cpcmd(cmd2, NULL, 0, &response);
597 if (response) {
Hongjie Yang93098bf2008-12-25 13:39:45 +0100598 pr_err("Saving a DCSS failed with SAVESEG response code "
599 "%i\n", response);
Gerald Schaefer9b5dec12006-04-27 18:40:22 -0700600 goto out;
601 }
602out:
Heiko Carstens09252e72006-12-04 15:40:51 +0100603 mutex_unlock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604}
605
Martin Schwidefskyca683052008-04-17 07:46:31 +0200606/*
607 * print appropriate error message for segment_load()/segment_type()
608 * return code
609 */
610void segment_warning(int rc, char *seg_name)
611{
612 switch (rc) {
613 case -ENOENT:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100614 pr_err("DCSS %s cannot be loaded or queried\n", seg_name);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200615 break;
616 case -ENOSYS:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100617 pr_err("DCSS %s cannot be loaded or queried without "
618 "z/VM\n", seg_name);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200619 break;
620 case -EIO:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100621 pr_err("Loading or querying DCSS %s resulted in a "
622 "hardware error\n", seg_name);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200623 break;
Heiko Carstensb8e660b2010-02-26 22:37:41 +0100624 case -EOPNOTSUPP:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100625 pr_err("DCSS %s has multiple page ranges and cannot be "
626 "loaded or queried\n", seg_name);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200627 break;
628 case -ENOSPC:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100629 pr_err("DCSS %s overlaps with used storage and cannot "
630 "be loaded\n", seg_name);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200631 break;
632 case -EBUSY:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100633 pr_err("%s needs used memory resources and cannot be "
634 "loaded or queried\n", seg_name);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200635 break;
636 case -EPERM:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100637 pr_err("DCSS %s is already loaded in a different access "
638 "mode\n", seg_name);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200639 break;
640 case -ENOMEM:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100641 pr_err("There is not enough memory to load or query "
642 "DCSS %s\n", seg_name);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200643 break;
644 case -ERANGE:
Hongjie Yang93098bf2008-12-25 13:39:45 +0100645 pr_err("DCSS %s exceeds the kernel mapping range (%lu) "
646 "and cannot be loaded\n", seg_name, VMEM_MAX_PHYS);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200647 break;
648 default:
Martin Schwidefskyca683052008-04-17 07:46:31 +0200649 break;
650 }
651}
652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653EXPORT_SYMBOL(segment_load);
654EXPORT_SYMBOL(segment_unload);
655EXPORT_SYMBOL(segment_save);
656EXPORT_SYMBOL(segment_type);
657EXPORT_SYMBOL(segment_modify_shared);
Martin Schwidefskyca683052008-04-17 07:46:31 +0200658EXPORT_SYMBOL(segment_warning);