?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fluff' into release
[linux-2.6/sactl.git] / arch / s390 / mm / extmem.c
blob580fc64cc735f343f2576baaba0bebb8eef2b3e9
1 /*
2 * File...........: arch/s390/mm/extmem.c
3 * 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>
7 * (C) IBM Corporation 2002-2004
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/string.h>
12 #include <linux/spinlock.h>
13 #include <linux/list.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/bootmem.h>
17 #include <linux/ctype.h>
18 #include <linux/ioport.h>
19 #include <asm/page.h>
20 #include <asm/pgtable.h>
21 #include <asm/ebcdic.h>
22 #include <asm/errno.h>
23 #include <asm/extmem.h>
24 #include <asm/cpcmd.h>
25 #include <asm/setup.h>
26
27 #define DCSS_DEBUG /* Debug messages on/off */
28
29 #define DCSS_NAME "extmem"
30 #ifdef DCSS_DEBUG
31 #define PRINT_DEBUG(x...) printk(KERN_DEBUG DCSS_NAME " debug:" x)
32 #else
33 #define PRINT_DEBUG(x...) do {} while (0)
34 #endif
35 #define PRINT_INFO(x...) printk(KERN_INFO DCSS_NAME " info:" x)
36 #define PRINT_WARN(x...) printk(KERN_WARNING DCSS_NAME " warning:" x)
37 #define PRINT_ERR(x...) printk(KERN_ERR DCSS_NAME " error:" x)
38
39
40 #define DCSS_LOADSHR 0x00
41 #define DCSS_LOADNSR 0x04
42 #define DCSS_PURGESEG 0x08
43 #define DCSS_FINDSEG 0x0c
44 #define DCSS_LOADNOLY 0x10
45 #define DCSS_SEGEXT 0x18
46 #define DCSS_LOADSHRX 0x20
47 #define DCSS_LOADNSRX 0x24
48 #define DCSS_FINDSEGX 0x2c
49 #define DCSS_SEGEXTX 0x38
50 #define DCSS_FINDSEGA 0x0c
51
52 struct qrange {
53 unsigned long start; /* last byte type */
54 unsigned long end; /* last byte reserved */
55 };
56
57 struct qout64 {
58 unsigned long segstart;
59 unsigned long segend;
60 int segcnt;
61 int segrcnt;
62 struct qrange range[6];
63 };
64
65 #ifdef CONFIG_64BIT
66 struct qrange_old {
67 unsigned int start; /* last byte type */
68 unsigned int end; /* last byte reserved */
69 };
70
71 /* output area format for the Diag x'64' old subcode x'18' */
72 struct qout64_old {
73 int segstart;
74 int segend;
75 int segcnt;
76 int segrcnt;
77 struct qrange_old range[6];
78 };
79 #endif
80
81 struct qin64 {
82 char qopcode;
83 char rsrv1[3];
84 char qrcode;
85 char rsrv2[3];
86 char qname[8];
87 unsigned int qoutptr;
88 short int qoutlen;
89 };
90
91 struct dcss_segment {
92 struct list_head list;
93 char dcss_name[8];
94 char res_name[15];
95 unsigned long start_addr;
96 unsigned long end;
97 atomic_t ref_count;
98 int do_nonshared;
99 unsigned int vm_segtype;
100 struct qrange range[6];
101 int segcnt;
102 struct resource *res;
103 };
104
105 static DEFINE_MUTEX(dcss_lock);
106 static LIST_HEAD(dcss_list);
107 static char *segtype_string[] = { "SW", "EW", "SR", "ER", "SN", "EN", "SC",
108 "EW/EN-MIXED" };
109 static int loadshr_scode, loadnsr_scode, findseg_scode;
110 static int segext_scode, purgeseg_scode;
111 static int scode_set;
112
113 /* set correct Diag x'64' subcodes. */
114 static int
115 dcss_set_subcodes(void)
116 {
117 #ifdef CONFIG_64BIT
118 char *name = kmalloc(8 * sizeof(char), GFP_DMA);
119 unsigned long rx, ry;
120 int rc;
121
122 if (name == NULL)
123 return -ENOMEM;
124
125 rx = (unsigned long) name;
126 ry = DCSS_FINDSEGX;
127
128 strcpy(name, "dummy");
129 asm volatile(
130 " diag %0,%1,0x64\n"
131 "0: ipm %2\n"
132 " srl %2,28\n"
133 " j 2f\n"
134 "1: la %2,3\n"
135 "2:\n"
136 EX_TABLE(0b, 1b)
137 : "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
138
139 kfree(name);
140 /* Diag x'64' new subcodes are supported, set to new subcodes */
141 if (rc != 3) {
142 loadshr_scode = DCSS_LOADSHRX;
143 loadnsr_scode = DCSS_LOADNSRX;
144 purgeseg_scode = DCSS_PURGESEG;
145 findseg_scode = DCSS_FINDSEGX;
146 segext_scode = DCSS_SEGEXTX;
147 return 0;
148 }
149 #endif
150 /* Diag x'64' new subcodes are not supported, set to old subcodes */
151 loadshr_scode = DCSS_LOADNOLY;
152 loadnsr_scode = DCSS_LOADNSR;
153 purgeseg_scode = DCSS_PURGESEG;
154 findseg_scode = DCSS_FINDSEG;
155 segext_scode = DCSS_SEGEXT;
156 return 0;
157 }
158
159 /*
160 * Create the 8 bytes, ebcdic VM segment name from
161 * an ascii name.
162 */
163 static void
164 dcss_mkname(char *name, char *dcss_name)
165 {
166 int i;
167
168 for (i = 0; i < 8; i++) {
169 if (name[i] == '\0')
170 break;
171 dcss_name[i] = toupper(name[i]);
172 };
173 for (; i < 8; i++)
174 dcss_name[i] = ' ';
175 ASCEBC(dcss_name, 8);
176 }
177
178
179 /*
180 * search all segments in dcss_list, and return the one
181 * namend *name. If not found, return NULL.
182 */
183 static struct dcss_segment *
184 segment_by_name (char *name)
185 {
186 char dcss_name[9];
187 struct list_head *l;
188 struct dcss_segment *tmp, *retval = NULL;
189
190 BUG_ON(!mutex_is_locked(&dcss_lock));
191 dcss_mkname (name, dcss_name);
192 list_for_each (l, &dcss_list) {
193 tmp = list_entry (l, struct dcss_segment, list);
194 if (memcmp(tmp->dcss_name, dcss_name, 8) == 0) {
195 retval = tmp;
196 break;
197 }
198 }
199 return retval;
200 }
201
202
203 /*
204 * Perform a function on a dcss segment.
205 */
206 static inline int
207 dcss_diag(int *func, void *parameter,
208 unsigned long *ret1, unsigned long *ret2)
209 {
210 unsigned long rx, ry;
211 int rc;
212
213 if (scode_set == 0) {
214 rc = dcss_set_subcodes();
215 if (rc < 0)
216 return rc;
217 scode_set = 1;
218 }
219 rx = (unsigned long) parameter;
220 ry = (unsigned long) *func;
221
222 #ifdef CONFIG_64BIT
223 /* 64-bit Diag x'64' new subcode, keep in 64-bit addressing mode */
224 if (*func > DCSS_SEGEXT)
225 asm volatile(
226 " diag %0,%1,0x64\n"
227 " ipm %2\n"
228 " srl %2,28\n"
229 : "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
230 /* 31-bit Diag x'64' old subcode, switch to 31-bit addressing mode */
231 else
232 asm volatile(
233 " sam31\n"
234 " diag %0,%1,0x64\n"
235 " sam64\n"
236 " ipm %2\n"
237 " srl %2,28\n"
238 : "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
239 #else
240 asm volatile(
241 " diag %0,%1,0x64\n"
242 " ipm %2\n"
243 " srl %2,28\n"
244 : "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
245 #endif
246 *ret1 = rx;
247 *ret2 = ry;
248 return rc;
249 }
250
251 static inline int
252 dcss_diag_translate_rc (int vm_rc) {
253 if (vm_rc == 44)
254 return -ENOENT;
255 return -EIO;
256 }
257
258
259 /* do a diag to get info about a segment.
260 * fills start_address, end and vm_segtype fields
261 */
262 static int
263 query_segment_type (struct dcss_segment *seg)
264 {
265 struct qin64 *qin = kmalloc (sizeof(struct qin64), GFP_DMA);
266 struct qout64 *qout = kmalloc (sizeof(struct qout64), GFP_DMA);
267
268 int diag_cc, rc, i;
269 unsigned long dummy, vmrc;
270
271 if ((qin == NULL) || (qout == NULL)) {
272 rc = -ENOMEM;
273 goto out_free;
274 }
275
276 /* initialize diag input parameters */
277 qin->qopcode = DCSS_FINDSEGA;
278 qin->qoutptr = (unsigned long) qout;
279 qin->qoutlen = sizeof(struct qout64);
280 memcpy (qin->qname, seg->dcss_name, 8);
281
282 diag_cc = dcss_diag(&segext_scode, qin, &dummy, &vmrc);
283
284 if (diag_cc < 0) {
285 rc = diag_cc;
286 goto out_free;
287 }
288 if (diag_cc > 1) {
289 PRINT_WARN ("segment_type: diag returned error %ld\n", vmrc);
290 rc = dcss_diag_translate_rc (vmrc);
291 goto out_free;
292 }
293
294 #ifdef CONFIG_64BIT
295 /* Only old format of output area of Diagnose x'64' is supported,
296 copy data for the new format. */
297 if (segext_scode == DCSS_SEGEXT) {
298 struct qout64_old *qout_old;
299 qout_old = kzalloc(sizeof(struct qout64_old), GFP_DMA);
300 if (qout_old == NULL) {
301 rc = -ENOMEM;
302 goto out_free;
303 }
304 memcpy(qout_old, qout, sizeof(struct qout64_old));
305 qout->segstart = (unsigned long) qout_old->segstart;
306 qout->segend = (unsigned long) qout_old->segend;
307 qout->segcnt = qout_old->segcnt;
308 qout->segrcnt = qout_old->segrcnt;
309
310 if (qout->segcnt > 6)
311 qout->segrcnt = 6;
312 for (i = 0; i < qout->segrcnt; i++) {
313 qout->range[i].start =
314 (unsigned long) qout_old->range[i].start;
315 qout->range[i].end =
316 (unsigned long) qout_old->range[i].end;
317 }
318 kfree(qout_old);
319 }
320 #endif
321 if (qout->segcnt > 6) {
322 rc = -ENOTSUPP;
323 goto out_free;
324 }
325
326 if (qout->segcnt == 1) {
327 seg->vm_segtype = qout->range[0].start & 0xff;
328 } else {
329 /* multi-part segment. only one type supported here:
330 - all parts are contiguous
331 - all parts are either EW or EN type
332 - maximum 6 parts allowed */
333 unsigned long start = qout->segstart >> PAGE_SHIFT;
334 for (i=0; i<qout->segcnt; i++) {
335 if (((qout->range[i].start & 0xff) != SEG_TYPE_EW) &&
336 ((qout->range[i].start & 0xff) != SEG_TYPE_EN)) {
337 rc = -ENOTSUPP;
338 goto out_free;
339 }
340 if (start != qout->range[i].start >> PAGE_SHIFT) {
341 rc = -ENOTSUPP;
342 goto out_free;
343 }
344 start = (qout->range[i].end >> PAGE_SHIFT) + 1;
345 }
346 seg->vm_segtype = SEG_TYPE_EWEN;
347 }
348
349 /* analyze diag output and update seg */
350 seg->start_addr = qout->segstart;
351 seg->end = qout->segend;
352
353 memcpy (seg->range, qout->range, 6*sizeof(struct qrange));
354 seg->segcnt = qout->segcnt;
355
356 rc = 0;
357
358 out_free:
359 kfree(qin);
360 kfree(qout);
361 return rc;
362 }
363
364 /*
365 * get info about a segment
366 * possible return values:
367 * -ENOSYS : we are not running on VM
368 * -EIO : could not perform query diagnose
369 * -ENOENT : no such segment
370 * -ENOTSUPP: multi-part segment cannot be used with linux
371 * -ENOSPC : segment cannot be used (overlaps with storage)
372 * -ENOMEM : out of memory
373 * 0 .. 6 : type of segment as defined in include/asm-s390/extmem.h
374 */
375 int
376 segment_type (char* name)
377 {
378 int rc;
379 struct dcss_segment seg;
380
381 if (!MACHINE_IS_VM)
382 return -ENOSYS;
383
384 dcss_mkname(name, seg.dcss_name);
385 rc = query_segment_type (&seg);
386 if (rc < 0)
387 return rc;
388 return seg.vm_segtype;
389 }
390
391 /*
392 * check if segment collides with other segments that are currently loaded
393 * returns 1 if this is the case, 0 if no collision was found
394 */
395 static int
396 segment_overlaps_others (struct dcss_segment *seg)
397 {
398 struct list_head *l;
399 struct dcss_segment *tmp;
400
401 BUG_ON(!mutex_is_locked(&dcss_lock));
402 list_for_each(l, &dcss_list) {
403 tmp = list_entry(l, struct dcss_segment, list);
404 if ((tmp->start_addr >> 20) > (seg->end >> 20))
405 continue;
406 if ((tmp->end >> 20) < (seg->start_addr >> 20))
407 continue;
408 if (seg == tmp)
409 continue;
410 return 1;
411 }
412 return 0;
413 }
414
415 /*
416 * real segment loading function, called from segment_load
417 */
418 static int
419 __segment_load (char *name, int do_nonshared, unsigned long *addr, unsigned long *end)
420 {
421 struct dcss_segment *seg = kmalloc(sizeof(struct dcss_segment),
422 GFP_DMA);
423 int rc, diag_cc;
424 unsigned long start_addr, end_addr, dummy;
425
426 if (seg == NULL) {
427 rc = -ENOMEM;
428 goto out;
429 }
430 dcss_mkname (name, seg->dcss_name);
431 rc = query_segment_type (seg);
432 if (rc < 0)
433 goto out_free;
434
435 if (loadshr_scode == DCSS_LOADSHRX) {
436 if (segment_overlaps_others(seg)) {
437 rc = -EBUSY;
438 goto out_free;
439 }
440 }
441
442 rc = vmem_add_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
443
444 if (rc)
445 goto out_free;
446
447 seg->res = kzalloc(sizeof(struct resource), GFP_KERNEL);
448 if (seg->res == NULL) {
449 rc = -ENOMEM;
450 goto out_shared;
451 }
452 seg->res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
453 seg->res->start = seg->start_addr;
454 seg->res->end = seg->end;
455 memcpy(&seg->res_name, seg->dcss_name, 8);
456 EBCASC(seg->res_name, 8);
457 seg->res_name[8] = '\0';
458 strncat(seg->res_name, " (DCSS)", 7);
459 seg->res->name = seg->res_name;
460 rc = seg->vm_segtype;
461 if (rc == SEG_TYPE_SC ||
462 ((rc == SEG_TYPE_SR || rc == SEG_TYPE_ER) && !do_nonshared))
463 seg->res->flags |= IORESOURCE_READONLY;
464 if (request_resource(&iomem_resource, seg->res)) {
465 rc = -EBUSY;
466 kfree(seg->res);
467 goto out_shared;
468 }
469
470 if (do_nonshared)
471 diag_cc = dcss_diag(&loadnsr_scode, seg->dcss_name,
472 &start_addr, &end_addr);
473 else
474 diag_cc = dcss_diag(&loadshr_scode, seg->dcss_name,
475 &start_addr, &end_addr);
476 if (diag_cc < 0) {
477 dcss_diag(&purgeseg_scode, seg->dcss_name,
478 &dummy, &dummy);
479 rc = diag_cc;
480 goto out_resource;
481 }
482 if (diag_cc > 1) {
483 PRINT_WARN ("segment_load: could not load segment %s - "
484 "diag returned error (%ld)\n",
485 name, end_addr);
486 rc = dcss_diag_translate_rc(end_addr);
487 dcss_diag(&purgeseg_scode, seg->dcss_name,
488 &dummy, &dummy);
489 goto out_resource;
490 }
491 seg->start_addr = start_addr;
492 seg->end = end_addr;
493 seg->do_nonshared = do_nonshared;
494 atomic_set(&seg->ref_count, 1);
495 list_add(&seg->list, &dcss_list);
496 *addr = seg->start_addr;
497 *end = seg->end;
498 if (do_nonshared)
499 PRINT_INFO ("segment_load: loaded segment %s range %p .. %p "
500 "type %s in non-shared mode\n", name,
501 (void*)seg->start_addr, (void*)seg->end,
502 segtype_string[seg->vm_segtype]);
503 else {
504 PRINT_INFO ("segment_load: loaded segment %s range %p .. %p "
505 "type %s in shared mode\n", name,
506 (void*)seg->start_addr, (void*)seg->end,
507 segtype_string[seg->vm_segtype]);
508 }
509 goto out;
510 out_resource:
511 release_resource(seg->res);
512 kfree(seg->res);
513 out_shared:
514 vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
515 out_free:
516 kfree(seg);
517 out:
518 return rc;
519 }
520
521 /*
522 * this function loads a DCSS segment
523 * name : name of the DCSS
524 * do_nonshared : 0 indicates that the dcss should be shared with other linux images
525 * 1 indicates that the dcss should be exclusive for this linux image
526 * addr : will be filled with start address of the segment
527 * end : will be filled with end address of the segment
528 * return values:
529 * -ENOSYS : we are not running on VM
530 * -EIO : could not perform query or load diagnose
531 * -ENOENT : no such segment
532 * -ENOTSUPP: multi-part segment cannot be used with linux
533 * -ENOSPC : segment cannot be used (overlaps with storage)
534 * -EBUSY : segment can temporarily not be used (overlaps with dcss)
535 * -ERANGE : segment cannot be used (exceeds kernel mapping range)
536 * -EPERM : segment is currently loaded with incompatible permissions
537 * -ENOMEM : out of memory
538 * 0 .. 6 : type of segment as defined in include/asm-s390/extmem.h
539 */
540 int
541 segment_load (char *name, int do_nonshared, unsigned long *addr,
542 unsigned long *end)
543 {
544 struct dcss_segment *seg;
545 int rc;
546
547 if (!MACHINE_IS_VM)
548 return -ENOSYS;
549
550 mutex_lock(&dcss_lock);
551 seg = segment_by_name (name);
552 if (seg == NULL)
553 rc = __segment_load (name, do_nonshared, addr, end);
554 else {
555 if (do_nonshared == seg->do_nonshared) {
556 atomic_inc(&seg->ref_count);
557 *addr = seg->start_addr;
558 *end = seg->end;
559 rc = seg->vm_segtype;
560 } else {
561 *addr = *end = 0;
562 rc = -EPERM;
563 }
564 }
565 mutex_unlock(&dcss_lock);
566 return rc;
567 }
568
569 /*
570 * this function modifies the shared state of a DCSS segment. note that
571 * name : name of the DCSS
572 * do_nonshared : 0 indicates that the dcss should be shared with other linux images
573 * 1 indicates that the dcss should be exclusive for this linux image
574 * return values:
575 * -EIO : could not perform load diagnose (segment gone!)
576 * -ENOENT : no such segment (segment gone!)
577 * -EAGAIN : segment is in use by other exploiters, try later
578 * -EINVAL : no segment with the given name is currently loaded - name invalid
579 * -EBUSY : segment can temporarily not be used (overlaps with dcss)
580 * 0 : operation succeeded
581 */
582 int
583 segment_modify_shared (char *name, int do_nonshared)
584 {
585 struct dcss_segment *seg;
586 unsigned long start_addr, end_addr, dummy;
587 int rc, diag_cc;
588
589 mutex_lock(&dcss_lock);
590 seg = segment_by_name (name);
591 if (seg == NULL) {
592 rc = -EINVAL;
593 goto out_unlock;
594 }
595 if (do_nonshared == seg->do_nonshared) {
596 PRINT_INFO ("segment_modify_shared: not reloading segment %s"
597 " - already in requested mode\n",name);
598 rc = 0;
599 goto out_unlock;
600 }
601 if (atomic_read (&seg->ref_count) != 1) {
602 PRINT_WARN ("segment_modify_shared: not reloading segment %s - "
603 "segment is in use by other driver(s)\n",name);
604 rc = -EAGAIN;
605 goto out_unlock;
606 }
607 release_resource(seg->res);
608 if (do_nonshared)
609 seg->res->flags &= ~IORESOURCE_READONLY;
610 else
611 if (seg->vm_segtype == SEG_TYPE_SR ||
612 seg->vm_segtype == SEG_TYPE_ER)
613 seg->res->flags |= IORESOURCE_READONLY;
614
615 if (request_resource(&iomem_resource, seg->res)) {
616 PRINT_WARN("segment_modify_shared: could not reload segment %s"
617 " - overlapping resources\n", name);
618 rc = -EBUSY;
619 kfree(seg->res);
620 goto out_del_mem;
621 }
622
623 dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
624 if (do_nonshared)
625 diag_cc = dcss_diag(&loadnsr_scode, seg->dcss_name,
626 &start_addr, &end_addr);
627 else
628 diag_cc = dcss_diag(&loadshr_scode, seg->dcss_name,
629 &start_addr, &end_addr);
630 if (diag_cc < 0) {
631 rc = diag_cc;
632 goto out_del_res;
633 }
634 if (diag_cc > 1) {
635 PRINT_WARN ("segment_modify_shared: could not reload segment %s"
636 " - diag returned error (%ld)\n",
637 name, end_addr);
638 rc = dcss_diag_translate_rc(end_addr);
639 goto out_del_res;
640 }
641 seg->start_addr = start_addr;
642 seg->end = end_addr;
643 seg->do_nonshared = do_nonshared;
644 rc = 0;
645 goto out_unlock;
646 out_del_res:
647 release_resource(seg->res);
648 kfree(seg->res);
649 out_del_mem:
650 vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
651 list_del(&seg->list);
652 dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
653 kfree(seg);
654 out_unlock:
655 mutex_unlock(&dcss_lock);
656 return rc;
657 }
658
659 /*
660 * Decrease the use count of a DCSS segment and remove
661 * it from the address space if nobody is using it
662 * any longer.
663 */
664 void
665 segment_unload(char *name)
666 {
667 unsigned long dummy;
668 struct dcss_segment *seg;
669
670 if (!MACHINE_IS_VM)
671 return;
672
673 mutex_lock(&dcss_lock);
674 seg = segment_by_name (name);
675 if (seg == NULL) {
676 PRINT_ERR ("could not find segment %s in segment_unload, "
677 "please report to linux390@de.ibm.com\n",name);
678 goto out_unlock;
679 }
680 if (atomic_dec_return(&seg->ref_count) != 0)
681 goto out_unlock;
682 release_resource(seg->res);
683 kfree(seg->res);
684 vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
685 list_del(&seg->list);
686 dcss_diag(&purgeseg_scode, seg->dcss_name, &dummy, &dummy);
687 kfree(seg);
688 out_unlock:
689 mutex_unlock(&dcss_lock);
690 }
691
692 /*
693 * save segment content permanently
694 */
695 void
696 segment_save(char *name)
697 {
698 struct dcss_segment *seg;
699 int startpfn = 0;
700 int endpfn = 0;
701 char cmd1[160];
702 char cmd2[80];
703 int i, response;
704
705 if (!MACHINE_IS_VM)
706 return;
707
708 mutex_lock(&dcss_lock);
709 seg = segment_by_name (name);
710
711 if (seg == NULL) {
712 PRINT_ERR("could not find segment %s in segment_save, please "
713 "report to linux390@de.ibm.com\n", name);
714 goto out;
715 }
716
717 startpfn = seg->start_addr >> PAGE_SHIFT;
718 endpfn = (seg->end) >> PAGE_SHIFT;
719 sprintf(cmd1, "DEFSEG %s", name);
720 for (i=0; i<seg->segcnt; i++) {
721 sprintf(cmd1+strlen(cmd1), " %lX-%lX %s",
722 seg->range[i].start >> PAGE_SHIFT,
723 seg->range[i].end >> PAGE_SHIFT,
724 segtype_string[seg->range[i].start & 0xff]);
725 }
726 sprintf(cmd2, "SAVESEG %s", name);
727 response = 0;
728 cpcmd(cmd1, NULL, 0, &response);
729 if (response) {
730 PRINT_ERR("segment_save: DEFSEG failed with response code %i\n",
731 response);
732 goto out;
733 }
734 cpcmd(cmd2, NULL, 0, &response);
735 if (response) {
736 PRINT_ERR("segment_save: SAVESEG failed with response code %i\n",
737 response);
738 goto out;
739 }
740 out:
741 mutex_unlock(&dcss_lock);
742 }
743
744 /*
745 * print appropriate error message for segment_load()/segment_type()
746 * return code
747 */
748 void segment_warning(int rc, char *seg_name)
749 {
750 switch (rc) {
751 case -ENOENT:
752 PRINT_WARN("cannot load/query segment %s, "
753 "does not exist\n", seg_name);
754 break;
755 case -ENOSYS:
756 PRINT_WARN("cannot load/query segment %s, "
757 "not running on VM\n", seg_name);
758 break;
759 case -EIO:
760 PRINT_WARN("cannot load/query segment %s, "
761 "hardware error\n", seg_name);
762 break;
763 case -ENOTSUPP:
764 PRINT_WARN("cannot load/query segment %s, "
765 "is a multi-part segment\n", seg_name);
766 break;
767 case -ENOSPC:
768 PRINT_WARN("cannot load/query segment %s, "
769 "overlaps with storage\n", seg_name);
770 break;
771 case -EBUSY:
772 PRINT_WARN("cannot load/query segment %s, "
773 "overlaps with already loaded dcss\n", seg_name);
774 break;
775 case -EPERM:
776 PRINT_WARN("cannot load/query segment %s, "
777 "already loaded in incompatible mode\n", seg_name);
778 break;
779 case -ENOMEM:
780 PRINT_WARN("cannot load/query segment %s, "
781 "out of memory\n", seg_name);
782 break;
783 case -ERANGE:
784 PRINT_WARN("cannot load/query segment %s, "
785 "exceeds kernel mapping range\n", seg_name);
786 break;
787 default:
788 PRINT_WARN("cannot load/query segment %s, "
789 "return value %i\n", seg_name, rc);
790 break;
791 }
792 }
793
794 EXPORT_SYMBOL(segment_load);
795 EXPORT_SYMBOL(segment_unload);
796 EXPORT_SYMBOL(segment_save);
797 EXPORT_SYMBOL(segment_type);
798 EXPORT_SYMBOL(segment_modify_shared);
799 EXPORT_SYMBOL(segment_warning);
SocketAccessConTroL development