blob: 394980b05e6fd91aaea02bacca57f81062690ad4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Heiko Carstens36a2bd42006-12-04 15:40:38 +010017#include <linux/ctype.h>
Gerald Schaefer444f0e52007-02-05 21:17:11 +010018#include <linux/ioport.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <asm/page.h>
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010020#include <asm/pgtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <asm/ebcdic.h>
22#include <asm/errno.h>
23#include <asm/extmem.h>
24#include <asm/cpcmd.h>
Heiko Carstens36a2bd42006-12-04 15:40:38 +010025#include <asm/setup.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
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_FINDSEGA 0x0c
47
48struct qrange {
49 unsigned int start; // 3byte start address, 1 byte type
50 unsigned int end; // 3byte end address, 1 byte reserved
51};
52
53struct qout64 {
54 int segstart;
55 int segend;
56 int segcnt;
57 int segrcnt;
58 struct qrange range[6];
59};
60
61struct qin64 {
62 char qopcode;
63 char rsrv1[3];
64 char qrcode;
65 char rsrv2[3];
66 char qname[8];
67 unsigned int qoutptr;
68 short int qoutlen;
69};
70
71struct dcss_segment {
72 struct list_head list;
73 char dcss_name[8];
Gerald Schaefer444f0e52007-02-05 21:17:11 +010074 char res_name[15];
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 unsigned long start_addr;
76 unsigned long end;
77 atomic_t ref_count;
78 int do_nonshared;
79 unsigned int vm_segtype;
80 struct qrange range[6];
81 int segcnt;
Gerald Schaefer444f0e52007-02-05 21:17:11 +010082 struct resource *res;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083};
84
Heiko Carstens09252e72006-12-04 15:40:51 +010085static DEFINE_MUTEX(dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086static struct list_head dcss_list = LIST_HEAD_INIT(dcss_list);
87static char *segtype_string[] = { "SW", "EW", "SR", "ER", "SN", "EN", "SC",
88 "EW/EN-MIXED" };
89
Linus Torvalds1da177e2005-04-16 15:20:36 -070090/*
91 * Create the 8 bytes, ebcdic VM segment name from
92 * an ascii name.
93 */
Heiko Carstens4d284ca2007-02-05 21:18:53 +010094static void
Linus Torvalds1da177e2005-04-16 15:20:36 -070095dcss_mkname(char *name, char *dcss_name)
96{
97 int i;
98
99 for (i = 0; i < 8; i++) {
100 if (name[i] == '\0')
101 break;
102 dcss_name[i] = toupper(name[i]);
103 };
104 for (; i < 8; i++)
105 dcss_name[i] = ' ';
106 ASCEBC(dcss_name, 8);
107}
108
109
110/*
111 * search all segments in dcss_list, and return the one
112 * namend *name. If not found, return NULL.
113 */
114static struct dcss_segment *
115segment_by_name (char *name)
116{
117 char dcss_name[9];
118 struct list_head *l;
119 struct dcss_segment *tmp, *retval = NULL;
120
Heiko Carstens09252e72006-12-04 15:40:51 +0100121 BUG_ON(!mutex_is_locked(&dcss_lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 dcss_mkname (name, dcss_name);
123 list_for_each (l, &dcss_list) {
124 tmp = list_entry (l, struct dcss_segment, list);
125 if (memcmp(tmp->dcss_name, dcss_name, 8) == 0) {
126 retval = tmp;
127 break;
128 }
129 }
130 return retval;
131}
132
133
134/*
135 * Perform a function on a dcss segment.
136 */
137static inline int
138dcss_diag (__u8 func, void *parameter,
139 unsigned long *ret1, unsigned long *ret2)
140{
141 unsigned long rx, ry;
142 int rc;
143
144 rx = (unsigned long) parameter;
145 ry = (unsigned long) func;
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200146 asm volatile(
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800147#ifdef CONFIG_64BIT
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200148 " sam31\n"
149 " diag %0,%1,0x64\n"
150 " sam64\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#else
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200152 " diag %0,%1,0x64\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153#endif
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200154 " ipm %2\n"
155 " srl %2,28\n"
156 : "+d" (rx), "+d" (ry), "=d" (rc) : : "cc");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 *ret1 = rx;
158 *ret2 = ry;
159 return rc;
160}
161
162static inline int
163dcss_diag_translate_rc (int vm_rc) {
164 if (vm_rc == 44)
165 return -ENOENT;
166 return -EIO;
167}
168
169
170/* do a diag to get info about a segment.
171 * fills start_address, end and vm_segtype fields
172 */
173static int
174query_segment_type (struct dcss_segment *seg)
175{
176 struct qin64 *qin = kmalloc (sizeof(struct qin64), GFP_DMA);
177 struct qout64 *qout = kmalloc (sizeof(struct qout64), GFP_DMA);
178
179 int diag_cc, rc, i;
180 unsigned long dummy, vmrc;
181
182 if ((qin == NULL) || (qout == NULL)) {
183 rc = -ENOMEM;
184 goto out_free;
185 }
186
187 /* initialize diag input parameters */
188 qin->qopcode = DCSS_FINDSEGA;
189 qin->qoutptr = (unsigned long) qout;
190 qin->qoutlen = sizeof(struct qout64);
191 memcpy (qin->qname, seg->dcss_name, 8);
192
193 diag_cc = dcss_diag (DCSS_SEGEXT, qin, &dummy, &vmrc);
194
195 if (diag_cc > 1) {
Gerald Schaefer9b5dec12006-04-27 18:40:22 -0700196 PRINT_WARN ("segment_type: diag returned error %ld\n", vmrc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 rc = dcss_diag_translate_rc (vmrc);
198 goto out_free;
199 }
200
201 if (qout->segcnt > 6) {
202 rc = -ENOTSUPP;
203 goto out_free;
204 }
205
206 if (qout->segcnt == 1) {
207 seg->vm_segtype = qout->range[0].start & 0xff;
208 } else {
209 /* multi-part segment. only one type supported here:
210 - all parts are contiguous
211 - all parts are either EW or EN type
212 - maximum 6 parts allowed */
213 unsigned long start = qout->segstart >> PAGE_SHIFT;
214 for (i=0; i<qout->segcnt; i++) {
215 if (((qout->range[i].start & 0xff) != SEG_TYPE_EW) &&
216 ((qout->range[i].start & 0xff) != SEG_TYPE_EN)) {
217 rc = -ENOTSUPP;
218 goto out_free;
219 }
220 if (start != qout->range[i].start >> PAGE_SHIFT) {
221 rc = -ENOTSUPP;
222 goto out_free;
223 }
224 start = (qout->range[i].end >> PAGE_SHIFT) + 1;
225 }
226 seg->vm_segtype = SEG_TYPE_EWEN;
227 }
228
229 /* analyze diag output and update seg */
230 seg->start_addr = qout->segstart;
231 seg->end = qout->segend;
232
233 memcpy (seg->range, qout->range, 6*sizeof(struct qrange));
234 seg->segcnt = qout->segcnt;
235
236 rc = 0;
237
238 out_free:
Jesper Juhlb2325fe2005-11-07 01:01:35 -0800239 kfree(qin);
240 kfree(qout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 return rc;
242}
243
244/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 * get info about a segment
246 * possible return values:
247 * -ENOSYS : we are not running on VM
248 * -EIO : could not perform query diagnose
249 * -ENOENT : no such segment
250 * -ENOTSUPP: multi-part segment cannot be used with linux
251 * -ENOSPC : segment cannot be used (overlaps with storage)
252 * -ENOMEM : out of memory
253 * 0 .. 6 : type of segment as defined in include/asm-s390/extmem.h
254 */
255int
256segment_type (char* name)
257{
258 int rc;
259 struct dcss_segment seg;
260
261 if (!MACHINE_IS_VM)
262 return -ENOSYS;
263
264 dcss_mkname(name, seg.dcss_name);
265 rc = query_segment_type (&seg);
266 if (rc < 0)
267 return rc;
268 return seg.vm_segtype;
269}
270
271/*
272 * real segment loading function, called from segment_load
273 */
274static int
275__segment_load (char *name, int do_nonshared, unsigned long *addr, unsigned long *end)
276{
277 struct dcss_segment *seg = kmalloc(sizeof(struct dcss_segment),
278 GFP_DMA);
279 int dcss_command, rc, diag_cc;
280
281 if (seg == NULL) {
282 rc = -ENOMEM;
283 goto out;
284 }
285 dcss_mkname (name, seg->dcss_name);
286 rc = query_segment_type (seg);
287 if (rc < 0)
288 goto out_free;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100289
290 rc = add_shared_memory(seg->start_addr, seg->end - seg->start_addr + 1);
291
292 switch (rc) {
293 case 0:
294 break;
295 case -ENOSPC:
296 PRINT_WARN("segment_load: not loading segment %s - overlaps "
297 "storage/segment\n", name);
298 goto out_free;
299 case -ERANGE:
300 PRINT_WARN("segment_load: not loading segment %s - exceeds "
301 "kernel mapping range\n", name);
302 goto out_free;
303 default:
304 PRINT_WARN("segment_load: not loading segment %s (rc: %d)\n",
305 name, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 goto out_free;
307 }
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100308
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100309 seg->res = kzalloc(sizeof(struct resource), GFP_KERNEL);
310 if (seg->res == NULL) {
311 rc = -ENOMEM;
312 goto out_shared;
313 }
314 seg->res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
315 seg->res->start = seg->start_addr;
316 seg->res->end = seg->end;
317 memcpy(&seg->res_name, seg->dcss_name, 8);
318 EBCASC(seg->res_name, 8);
319 seg->res_name[8] = '\0';
320 strncat(seg->res_name, " (DCSS)", 7);
321 seg->res->name = seg->res_name;
322 rc = seg->vm_segtype;
323 if (rc == SEG_TYPE_SC ||
324 ((rc == SEG_TYPE_SR || rc == SEG_TYPE_ER) && !do_nonshared))
325 seg->res->flags |= IORESOURCE_READONLY;
326 if (request_resource(&iomem_resource, seg->res)) {
327 rc = -EBUSY;
328 kfree(seg->res);
329 goto out_shared;
330 }
331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 if (do_nonshared)
333 dcss_command = DCSS_LOADNSR;
334 else
335 dcss_command = DCSS_LOADNOLY;
336
337 diag_cc = dcss_diag(dcss_command, seg->dcss_name,
338 &seg->start_addr, &seg->end);
339 if (diag_cc > 1) {
340 PRINT_WARN ("segment_load: could not load segment %s - "
341 "diag returned error (%ld)\n",name,seg->end);
342 rc = dcss_diag_translate_rc (seg->end);
343 dcss_diag(DCSS_PURGESEG, seg->dcss_name,
344 &seg->start_addr, &seg->end);
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100345 goto out_resource;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 }
347 seg->do_nonshared = do_nonshared;
348 atomic_set(&seg->ref_count, 1);
349 list_add(&seg->list, &dcss_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 *addr = seg->start_addr;
351 *end = seg->end;
352 if (do_nonshared)
353 PRINT_INFO ("segment_load: loaded segment %s range %p .. %p "
354 "type %s in non-shared mode\n", name,
355 (void*)seg->start_addr, (void*)seg->end,
356 segtype_string[seg->vm_segtype]);
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100357 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 PRINT_INFO ("segment_load: loaded segment %s range %p .. %p "
359 "type %s in shared mode\n", name,
360 (void*)seg->start_addr, (void*)seg->end,
361 segtype_string[seg->vm_segtype]);
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 goto out;
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100364 out_resource:
365 release_resource(seg->res);
366 kfree(seg->res);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100367 out_shared:
368 remove_shared_memory(seg->start_addr, seg->end - seg->start_addr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 out_free:
Jesper Juhlb2325fe2005-11-07 01:01:35 -0800370 kfree(seg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 out:
372 return rc;
373}
374
375/*
376 * this function loads a DCSS segment
377 * name : name of the DCSS
378 * do_nonshared : 0 indicates that the dcss should be shared with other linux images
379 * 1 indicates that the dcss should be exclusive for this linux image
380 * addr : will be filled with start address of the segment
381 * end : will be filled with end address of the segment
382 * return values:
383 * -ENOSYS : we are not running on VM
384 * -EIO : could not perform query or load diagnose
385 * -ENOENT : no such segment
386 * -ENOTSUPP: multi-part segment cannot be used with linux
387 * -ENOSPC : segment cannot be used (overlaps with storage)
388 * -EBUSY : segment can temporarily not be used (overlaps with dcss)
389 * -ERANGE : segment cannot be used (exceeds kernel mapping range)
390 * -EPERM : segment is currently loaded with incompatible permissions
391 * -ENOMEM : out of memory
392 * 0 .. 6 : type of segment as defined in include/asm-s390/extmem.h
393 */
394int
395segment_load (char *name, int do_nonshared, unsigned long *addr,
396 unsigned long *end)
397{
398 struct dcss_segment *seg;
399 int rc;
400
401 if (!MACHINE_IS_VM)
402 return -ENOSYS;
403
Heiko Carstens09252e72006-12-04 15:40:51 +0100404 mutex_lock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 seg = segment_by_name (name);
406 if (seg == NULL)
407 rc = __segment_load (name, do_nonshared, addr, end);
408 else {
409 if (do_nonshared == seg->do_nonshared) {
410 atomic_inc(&seg->ref_count);
411 *addr = seg->start_addr;
412 *end = seg->end;
413 rc = seg->vm_segtype;
414 } else {
415 *addr = *end = 0;
416 rc = -EPERM;
417 }
418 }
Heiko Carstens09252e72006-12-04 15:40:51 +0100419 mutex_unlock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 return rc;
421}
422
423/*
424 * this function modifies the shared state of a DCSS segment. note that
425 * name : name of the DCSS
426 * do_nonshared : 0 indicates that the dcss should be shared with other linux images
427 * 1 indicates that the dcss should be exclusive for this linux image
428 * return values:
429 * -EIO : could not perform load diagnose (segment gone!)
430 * -ENOENT : no such segment (segment gone!)
431 * -EAGAIN : segment is in use by other exploiters, try later
432 * -EINVAL : no segment with the given name is currently loaded - name invalid
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100433 * -EBUSY : segment can temporarily not be used (overlaps with dcss)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 * 0 : operation succeeded
435 */
436int
437segment_modify_shared (char *name, int do_nonshared)
438{
439 struct dcss_segment *seg;
440 unsigned long dummy;
441 int dcss_command, rc, diag_cc;
442
Heiko Carstens09252e72006-12-04 15:40:51 +0100443 mutex_lock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 seg = segment_by_name (name);
445 if (seg == NULL) {
446 rc = -EINVAL;
447 goto out_unlock;
448 }
449 if (do_nonshared == seg->do_nonshared) {
450 PRINT_INFO ("segment_modify_shared: not reloading segment %s"
451 " - already in requested mode\n",name);
452 rc = 0;
453 goto out_unlock;
454 }
455 if (atomic_read (&seg->ref_count) != 1) {
456 PRINT_WARN ("segment_modify_shared: not reloading segment %s - "
457 "segment is in use by other driver(s)\n",name);
458 rc = -EAGAIN;
459 goto out_unlock;
460 }
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100461 release_resource(seg->res);
462 if (do_nonshared) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 dcss_command = DCSS_LOADNSR;
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100464 seg->res->flags &= ~IORESOURCE_READONLY;
465 } else {
466 dcss_command = DCSS_LOADNOLY;
467 if (seg->vm_segtype == SEG_TYPE_SR ||
468 seg->vm_segtype == SEG_TYPE_ER)
469 seg->res->flags |= IORESOURCE_READONLY;
470 }
471 if (request_resource(&iomem_resource, seg->res)) {
472 PRINT_WARN("segment_modify_shared: could not reload segment %s"
473 " - overlapping resources\n", name);
474 rc = -EBUSY;
475 kfree(seg->res);
476 goto out_del;
477 }
478 dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 diag_cc = dcss_diag(dcss_command, seg->dcss_name,
480 &seg->start_addr, &seg->end);
481 if (diag_cc > 1) {
482 PRINT_WARN ("segment_modify_shared: could not reload segment %s"
483 " - diag returned error (%ld)\n",name,seg->end);
484 rc = dcss_diag_translate_rc (seg->end);
485 goto out_del;
486 }
487 seg->do_nonshared = do_nonshared;
488 rc = 0;
489 goto out_unlock;
490 out_del:
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100491 remove_shared_memory(seg->start_addr, seg->end - seg->start_addr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 list_del(&seg->list);
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100493 dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
Jesper Juhlb2325fe2005-11-07 01:01:35 -0800494 kfree(seg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 out_unlock:
Heiko Carstens09252e72006-12-04 15:40:51 +0100496 mutex_unlock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 return rc;
498}
499
500/*
501 * Decrease the use count of a DCSS segment and remove
502 * it from the address space if nobody is using it
503 * any longer.
504 */
505void
506segment_unload(char *name)
507{
508 unsigned long dummy;
509 struct dcss_segment *seg;
510
511 if (!MACHINE_IS_VM)
512 return;
513
Heiko Carstens09252e72006-12-04 15:40:51 +0100514 mutex_lock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 seg = segment_by_name (name);
516 if (seg == NULL) {
517 PRINT_ERR ("could not find segment %s in segment_unload, "
518 "please report to linux390@de.ibm.com\n",name);
519 goto out_unlock;
520 }
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100521 if (atomic_dec_return(&seg->ref_count) != 0)
522 goto out_unlock;
Gerald Schaefer444f0e52007-02-05 21:17:11 +0100523 release_resource(seg->res);
524 kfree(seg->res);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100525 remove_shared_memory(seg->start_addr, seg->end - seg->start_addr + 1);
526 list_del(&seg->list);
527 dcss_diag(DCSS_PURGESEG, seg->dcss_name, &dummy, &dummy);
528 kfree(seg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529out_unlock:
Heiko Carstens09252e72006-12-04 15:40:51 +0100530 mutex_unlock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531}
532
533/*
534 * save segment content permanently
535 */
536void
537segment_save(char *name)
538{
539 struct dcss_segment *seg;
540 int startpfn = 0;
541 int endpfn = 0;
542 char cmd1[160];
543 char cmd2[80];
Gerald Schaefer9b5dec12006-04-27 18:40:22 -0700544 int i, response;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
546 if (!MACHINE_IS_VM)
547 return;
548
Heiko Carstens09252e72006-12-04 15:40:51 +0100549 mutex_lock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 seg = segment_by_name (name);
551
552 if (seg == NULL) {
Heiko Carstens6b4044b2006-12-04 15:40:20 +0100553 PRINT_ERR("could not find segment %s in segment_save, please "
554 "report to linux390@de.ibm.com\n", name);
555 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 }
557
558 startpfn = seg->start_addr >> PAGE_SHIFT;
559 endpfn = (seg->end) >> PAGE_SHIFT;
560 sprintf(cmd1, "DEFSEG %s", name);
561 for (i=0; i<seg->segcnt; i++) {
562 sprintf(cmd1+strlen(cmd1), " %X-%X %s",
563 seg->range[i].start >> PAGE_SHIFT,
564 seg->range[i].end >> PAGE_SHIFT,
565 segtype_string[seg->range[i].start & 0xff]);
566 }
567 sprintf(cmd2, "SAVESEG %s", name);
Gerald Schaefer9b5dec12006-04-27 18:40:22 -0700568 response = 0;
569 cpcmd(cmd1, NULL, 0, &response);
570 if (response) {
571 PRINT_ERR("segment_save: DEFSEG failed with response code %i\n",
572 response);
573 goto out;
574 }
575 cpcmd(cmd2, NULL, 0, &response);
576 if (response) {
577 PRINT_ERR("segment_save: SAVESEG failed with response code %i\n",
578 response);
579 goto out;
580 }
581out:
Heiko Carstens09252e72006-12-04 15:40:51 +0100582 mutex_unlock(&dcss_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583}
584
585EXPORT_SYMBOL(segment_load);
586EXPORT_SYMBOL(segment_unload);
587EXPORT_SYMBOL(segment_save);
588EXPORT_SYMBOL(segment_type);
589EXPORT_SYMBOL(segment_modify_shared);