Annotation of prex-old/sys/mem/vm_nommu.c, Revision 1.1.1.1
1.1 nbrk 1: /*-
2: * Copyright (c) 2005-2006, Kohsuke Ohtani
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. Neither the name of the author nor the names of any co-contributors
14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: */
29:
30: /*
31: * vm_nommu.c - virtual memory functions for no MMU systems
32: */
33:
34: /*
35: * When the platform does not support memory management unit (MMU)
36: * all virtual memories are mapped to the physical memory. So, the
37: * memory space is shared among all tasks and kernel.
38: *
39: * Important: The lists of regions are not sorted by address.
40: */
41:
42: #include <kernel.h>
43: #include <kmem.h>
44: #include <thread.h>
45: #include <page.h>
46: #include <task.h>
47: #include <sched.h>
48: #include <vm.h>
49:
50: #ifdef CONFIG_VMTRACE
51: static void vm_error(const char *, int);
52: #define LOG(x) printk x
53: #define CHK(fn,x) do { if (x) vm_error(fn, x); } while (0)
54: #else
55: #define LOG(x)
56: #define CHK(fn,x)
57: #endif
58:
59: /* forward declarations */
60: static struct region *region_create(struct region *, u_long, size_t);
61: static void region_delete(struct region *, struct region *);
62: static struct region *region_find(struct region *, u_long, size_t);
63: static void region_free(struct region *, struct region *);
64: static void region_init(struct region *);
65: static int do_allocate(vm_map_t, void **, size_t, int);
66: static int do_free(vm_map_t, void *);
67: static int do_attribute(vm_map_t, void *, int);
68: static int do_map(vm_map_t, void *, size_t, void **);
69:
70: /* vm mapping for kernel task */
71: static struct vm_map kern_map;
72:
73: /**
74: * vm_allocate - allocate zero-filled memory for specified address
75: * @task: task id to allocate memory
76: * @addr: required address. set an allocated address in return.
77: * @size: allocation size
78: * @anywhere: if it is true, the "addr" argument will be ignored.
79: * In this case, the address of free space will be found
80: * automatically.
81: *
82: * The allocated area has writable, user-access attribute by default.
83: * The "addr" and "size" argument will be adjusted to page boundary.
84: */
85: int
86: vm_allocate(task_t task, void **addr, size_t size, int anywhere)
87: {
88: int err;
89: void *uaddr;
90:
91: LOG(("vm_aloc: task=%s addr=%x size=%x anywhere=%d\n",
92: task->name ? task->name : "no name", *addr, size, anywhere));
93:
94: sched_lock();
95:
96: if (!task_valid(task)) {
97: err = ESRCH;
98: } else if (task != cur_task() && !task_capable(CAP_MEMORY)) {
99: err = EPERM;
100: } else if (umem_copyin(addr, &uaddr, sizeof(void *))) {
101: err = EFAULT;
102: } else if (anywhere == 0 && !user_area(*addr)) {
103: err = EACCES;
104: } else {
105: err = do_allocate(task->map, &uaddr, size, anywhere);
106: if (err == 0) {
107: if (umem_copyout(&uaddr, addr, sizeof(void *)))
108: err = EFAULT;
109: }
110: }
111: sched_unlock();
112: CHK("vm_allocate", err);
113: return err;
114: }
115:
116: static int
117: do_allocate(vm_map_t map, void **addr, size_t size, int anywhere)
118: {
119: struct region *reg;
120: u_long start, end;
121:
122: if (size == 0)
123: return EINVAL;
124:
125: /*
126: * Allocate region, and reserve pages for it.
127: */
128: if (anywhere) {
129: size = (size_t)PAGE_ALIGN(size);
130: if ((start = (u_long)page_alloc(size)) == 0)
131: return ENOMEM;
132: } else {
133: start = PAGE_TRUNC(*addr);
134: end = PAGE_ALIGN(start + size);
135: size = (size_t)(end - start);
136:
137: if (page_reserve((void *)start, size))
138: return EINVAL;
139: }
140: reg = region_create(&map->head, start, size);
141: if (reg == NULL) {
142: page_free((void *)start, size);
143: return ENOMEM;
144: }
145: reg->flags = REG_READ | REG_WRITE;
146:
147: /* Zero fill */
148: memset((void *)start, 0, size);
149: *addr = (void *)reg->addr;
150: return 0;
151: }
152:
153: /*
154: * Deallocate memory region for specified address.
155: *
156: * The "addr" argument points to a memory region previously
157: * allocated through a call to vm_allocate() or vm_map(). The number
158: * of bytes freed is the number of bytes of the allocated region.
159: * If one of the region of previous and next are free, it combines
160: * with them, and larger free region is created.
161: */
162: int
163: vm_free(task_t task, void *addr)
164: {
165: int err;
166:
167: LOG(("vm_free: task=%s addr=%x\n",
168: task->name ? task->name : "no name", addr));
169:
170: sched_lock();
171: if (!task_valid(task)) {
172: err = ESRCH;
173: } else if (task != cur_task() && !task_capable(CAP_MEMORY)) {
174: err = EPERM;
175: } else if (!user_area(addr)) {
176: err = EFAULT;
177: } else {
178: err = do_free(task->map, addr);
179: }
180: sched_unlock();
181: CHK("vm_free", err);
182: return err;
183: }
184:
185: static int
186: do_free(vm_map_t map, void *addr)
187: {
188: struct region *reg;
189:
190: addr = (void *)PAGE_TRUNC(addr);
191:
192: /*
193: * Find the target region.
194: */
195: reg = region_find(&map->head, (u_long)addr, 1);
196: if (reg == NULL || reg->addr != (u_long)addr ||
197: (reg->flags & REG_FREE))
198: return EINVAL; /* not allocated */
199:
200: /*
201: * Free pages if it is not shared and mapped.
202: */
203: if (!(reg->flags & REG_SHARED) && !(reg->flags & REG_MAPPED))
204: page_free((void *)reg->addr, reg->size);
205:
206: region_free(&map->head, reg);
207: return 0;
208: }
209:
210: /*
211: * Change attribute of specified virtual address.
212: *
213: * The "addr" argument points to a memory region previously allocated
214: * through a call to vm_allocate(). The attribute type can be chosen
215: * a combination of VMA_READ, VMA_WRITE.
216: * Note: VMA_EXEC is not supported, yet.
217: */
218: int
219: vm_attribute(task_t task, void *addr, int attr)
220: {
221: int err;
222:
223: LOG(("vm_attr: task=%s addr=%x attr=%x\n",
224: task->name ? task->name : "no name", addr, attr));
225:
226: sched_lock();
227: if (attr == 0 || attr & ~(VMA_READ | VMA_WRITE)) {
228: err = EINVAL;
229: } else if (!task_valid(task)) {
230: err = ESRCH;
231: } else if (task != cur_task() && !task_capable(CAP_MEMORY)) {
232: err = EPERM;
233: } else if (!user_area(addr)) {
234: err = EFAULT;
235: } else {
236: err = do_attribute(task->map, addr, attr);
237: }
238: sched_unlock();
239: CHK("vm_attribute", err);
240: return err;
241: }
242:
243: static int
244: do_attribute(vm_map_t map, void *addr, int attr)
245: {
246: struct region *reg;
247: int new_flags = 0;
248:
249: addr = (void *)PAGE_TRUNC(addr);
250:
251: /*
252: * Find the target region.
253: */
254: reg = region_find(&map->head, (u_long)addr, 1);
255: if (reg == NULL || reg->addr != (u_long)addr ||
256: (reg->flags & REG_FREE)) {
257: return EINVAL; /* not allocated */
258: }
259: /*
260: * The attribute of the mapped or shared region can not be changed.
261: */
262: if ((reg->flags & REG_MAPPED) || (reg->flags & REG_SHARED))
263: return EINVAL;
264:
265: /*
266: * Check new and old flag.
267: */
268: if (reg->flags & REG_WRITE) {
269: if (!(attr & VMA_WRITE))
270: new_flags = REG_READ;
271: } else {
272: if (attr & VMA_WRITE)
273: new_flags = REG_READ | REG_WRITE;
274: }
275: if (new_flags == 0)
276: return 0; /* same attribute */
277: reg->flags = new_flags;
278: return 0;
279: }
280:
281: /**
282: * vm_map - map another task's memory to current task.
283: * @target: memory owner
284: * @addr: target address
285: * @size: map size
286: * @alloc: map address returned
287: *
288: * Note: This routine does not support mapping to the specific address.
289: */
290: int
291: vm_map(task_t target, void *addr, size_t size, void **alloc)
292: {
293: int err;
294:
295: LOG(("vm_map : task=%s addr=%x size=%x\n",
296: target->name ? target->name : "no name", addr, size));
297:
298: sched_lock();
299: if (!task_valid(target)) {
300: err = ESRCH;
301: } else if (target == cur_task()) {
302: err = EINVAL;
303: } else if (!task_capable(CAP_MEMORY)) {
304: err = EPERM;
305: } else if (!user_area(addr)) {
306: err = EFAULT;
307: } else {
308: err = do_map(target->map, addr, size, alloc);
309: }
310: sched_unlock();
311: CHK("vm_map", err);
312: return err;
313: }
314:
315: static int
316: do_map(vm_map_t map, void *addr, size_t size, void **alloc)
317: {
318: vm_map_t curmap;
319: u_long start, end;
320: struct region *reg, *tgt;
321: void *tmp;
322:
323: if (size == 0)
324: return EINVAL;
325:
326: /* check fault */
327: tmp = NULL;
328: if (umem_copyout(&tmp, alloc, sizeof(void *)))
329: return EFAULT;
330:
331: start = PAGE_TRUNC(addr);
332: end = PAGE_ALIGN((u_long)addr + size);
333: size = (size_t)(end - start);
334:
335: /*
336: * Find the region that includes target address
337: */
338: reg = region_find(&map->head, start, size);
339: if (reg == NULL || (reg->flags & REG_FREE))
340: return EINVAL; /* not allocated */
341: tgt = reg;
342:
343: /*
344: * Create new region to map
345: */
346: curmap = cur_task()->map;
347: reg = region_create(&curmap->head, start, size);
348: if (reg == NULL)
349: return ENOMEM;
350: reg->flags = tgt->flags | REG_MAPPED;
351:
352: umem_copyout(&addr, alloc, sizeof(void *));
353: return 0;
354: }
355:
356: /*
357: * Create new virtual memory space.
358: * No memory is inherited.
359: * Must be called with scheduler locked.
360: */
361: vm_map_t
362: vm_create(void)
363: {
364: vm_map_t map;
365:
366: /* Allocate new map structure */
367: if ((map = kmem_alloc(sizeof(struct vm_map))) == NULL)
368: return NULL;
369:
370: map->ref_count = 1;
371: region_init(&map->head);
372: return map;
373: }
374:
375: /*
376: * Terminate specified virtual memory space.
377: * This is called when task is terminated.
378: */
379: void
380: vm_terminate(vm_map_t map)
381: {
382: struct region *reg, *tmp;
383:
384: if (--map->ref_count >= 1)
385: return;
386:
387: sched_lock();
388: reg = &map->head;
389: do {
390: if (reg->flags != REG_FREE) {
391: /* Free region if it is not shared and mapped */
392: if (!(reg->flags & REG_SHARED) &&
393: !(reg->flags & REG_MAPPED)) {
394: page_free((void *)reg->addr, reg->size);
395: }
396: }
397: tmp = reg;
398: reg = reg->next;
399: region_delete(&map->head, tmp);
400: } while (reg != &map->head);
401:
402: kmem_free(map);
403: sched_unlock();
404: }
405:
406: /*
407: * Duplicate specified virtual memory space.
408: */
409: vm_map_t
410: vm_fork(vm_map_t org_map)
411: {
412: /*
413: * This function is not supported with no MMU system.
414: */
415: return NULL;
416: }
417:
418: /*
419: * Switch VM mapping.
420: */
421: void
422: vm_switch(vm_map_t map)
423: {
424: }
425:
426: /*
427: * Increment reference count of VM mapping.
428: */
429: int
430: vm_reference(vm_map_t map)
431: {
432:
433: map->ref_count++;
434: return 0;
435: }
436:
437: /*
438: * Translate virtual address of current task to physical address.
439: * Returns physical address on success, or NULL if no mapped memory.
440: */
441: void *
442: vm_translate(void *addr, size_t size)
443: {
444: return addr;
445: }
446:
447: /*
448: * Check if specified access can be allowed.
449: * return 0 on success, or EFAULT on failure.
450: */
451: int
452: vm_access(void *addr, size_t size, int type)
453: {
454: u_long start, end;
455: int err;
456: char tmp;
457:
458: ASSERT(size);
459: start = (u_long)addr;
460: end = (u_long)addr + size - 1;
461: if ((err = umem_copyin((void *)start, &tmp, 1)))
462: return EFAULT;
463: if (type == VMA_WRITE) {
464: if ((err = umem_copyout(&tmp, (void *)start, 1)))
465: return EFAULT;
466: }
467: if ((err = umem_copyin((void *)end, &tmp, 1)))
468: return EFAULT;
469: if (type == VMA_WRITE) {
470: if ((err = umem_copyout(&tmp, (void *)end, 1)))
471: return EFAULT;
472: }
473: return 0;
474: }
475:
476: /*
477: * Reserve specific area for boot tasks.
478: */
479: static int
480: do_reserve(vm_map_t map, void **addr, size_t size)
481: {
482: struct region *reg;
483: u_long start, end;
484:
485: if (size == 0)
486: return EINVAL;
487:
488: start = PAGE_TRUNC(*addr);
489: end = PAGE_ALIGN(start + size);
490: size = (size_t)(end - start);
491:
492: reg = region_create(&map->head, start, size);
493: if (reg == NULL)
494: return ENOMEM;
495: reg->flags = REG_READ | REG_WRITE;
496: *addr = (void *)reg->addr;
497: return 0;
498: }
499:
500: /*
501: * Setup task image for boot task. (NOMMU version)
502: * Return 0 on success, -1 on failure.
503: *
504: * Note: We assume that the task images are already copied to
505: * the proper address by a boot loader.
506: */
507: int
508: vm_load(vm_map_t map, struct module *m, void **stack)
509: {
510: void *base;
511: size_t size;
512:
513: printk("Loading task:\'%s\'\n", m->name);
514:
515: /*
516: * Reserve text & data area
517: */
518: base = (void *)m->text;
519: size = m->textsz + m->datasz + m->bsssz;
520: if (do_reserve(map, &base, size))
521: return -1;
522: if (m->bsssz != 0)
523: memset((void *)(m->data + m->datasz), 0, m->bsssz);
524:
525: /*
526: * Create stack
527: */
528: if (do_allocate(map, stack, USTACK_SIZE, 1))
529: return -1;
530: return 0;
531: }
532:
533: /*
534: * Create new free region after the specified region.
535: * Returns region on success, or NULL on failure.
536: */
537: static struct region *
538: region_create(struct region *prev, u_long addr, size_t size)
539: {
540: struct region *reg;
541:
542: if ((reg = kmem_alloc(sizeof(struct region))) == NULL)
543: return NULL;
544:
545: reg->addr = addr;
546: reg->size = size;
547: reg->flags = REG_FREE;
548: reg->sh_next = reg->sh_prev = reg;
549:
550: reg->next = prev->next;
551: reg->prev = prev;
552: prev->next->prev = reg;
553: prev->next = reg;
554: return reg;
555: }
556:
557: /*
558: * Delete specified region
559: */
560: static void
561: region_delete(struct region *head, struct region *reg)
562: {
563:
564: /*
565: * If it is shared region, unlink from shared list.
566: */
567: if (reg->flags & REG_SHARED) {
568: reg->sh_prev->sh_next = reg->sh_next;
569: reg->sh_next->sh_prev = reg->sh_prev;
570: if (reg->sh_prev == reg->sh_next)
571: reg->sh_prev->flags &= ~REG_SHARED;
572: }
573: if (head != reg)
574: kmem_free(reg);
575: }
576:
577: /*
578: * Find the region at the specified area.
579: */
580: static struct region *
581: region_find(struct region *head, u_long addr, size_t size)
582: {
583: struct region *reg;
584:
585: reg = head;
586: do {
587: if (reg->addr <= addr &&
588: reg->addr + reg->size >= addr + size) {
589: return reg;
590: }
591: reg = reg->next;
592: } while (reg != head);
593: return NULL;
594: }
595:
596: /*
597: * Free specified region
598: */
599: static void
600: region_free(struct region *head, struct region *reg)
601: {
602: ASSERT(reg->flags != REG_FREE);
603:
604: /*
605: * If it is shared region, unlink from shared list.
606: */
607: if (reg->flags & REG_SHARED) {
608: reg->sh_prev->sh_next = reg->sh_next;
609: reg->sh_next->sh_prev = reg->sh_prev;
610: if (reg->sh_prev == reg->sh_next)
611: reg->sh_prev->flags &= ~REG_SHARED;
612: }
613: reg->prev->next = reg->next;
614: reg->next->prev = reg->prev;
615: kmem_free(reg);
616: }
617:
618: /*
619: * Initialize region
620: */
621: static void
622: region_init(struct region *reg)
623: {
624:
625: reg->next = reg->prev = reg;
626: reg->sh_next = reg->sh_prev = reg;
627: reg->addr = 0;
628: reg->size = 0;
629: reg->flags = REG_FREE;
630: }
631:
632: #if defined(DEBUG) && defined(CONFIG_KDUMP)
633: void
634: vm_dump_one(task_t task)
635: {
636: vm_map_t map;
637: struct region *reg;
638: char flags[6];
639: u_long total = 0;
640:
641: printk("task=%x map=%x name=%s\n", task, task->map,
642: task->name ? task->name : "no name");
643: printk(" region virtual size flags\n");
644: printk(" -------- -------- -------- -----\n");
645:
646: map = task->map;
647: reg = &map->head;
648: do {
649: if (reg->flags != REG_FREE) {
650: strlcpy(flags, "-----", 6);
651: if (reg->flags & REG_READ)
652: flags[0] = 'R';
653: if (reg->flags & REG_WRITE)
654: flags[1] = 'W';
655: if (reg->flags & REG_EXEC)
656: flags[2] = 'E';
657: if (reg->flags & REG_SHARED)
658: flags[3] = 'S';
659: if (reg->flags & REG_MAPPED)
660: flags[4] = 'M';
661:
662: printk(" %08x %08x %08x %s\n", reg,
663: reg->addr, reg->size, flags);
664: if ((reg->flags & REG_MAPPED) == 0)
665: total += reg->size;
666: }
667: reg = reg->next;
668: } while (reg != &map->head); /* Process all regions */
669: printk(" *total=%dK bytes\n\n", total / 1024);
670: }
671:
672: void
673: vm_dump(void)
674: {
675: list_t n;
676: task_t task;
677:
678: printk("\nVM dump:\n");
679: n = &kern_task.link;
680: do {
681: task = list_entry(n, struct task, link);
682: ASSERT(task_valid(task));
683: vm_dump_one(task);
684: n = list_next(n);
685: } while (n != &kern_task.link);
686: }
687: #endif
688:
689:
690: #ifdef CONFIG_VMTRACE
691: static void
692: vm_error(const char *func, int err)
693: {
694: printk("Error!!: %s returns err=%x\n", func, err);
695: }
696: #endif
697:
698: void
699: vm_init(void)
700: {
701:
702: region_init(&kern_map.head);
703: kern_task.map = &kern_map;
704: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to vm_nommu.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / sys / mem