URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [mm/] [vmalloc.c] - Blame information for rev 1782

Details | Compare with Previous | View Log


/*
 *  linux/mm/vmalloc.c
 *
 *  Copyright (C) 1993  Linus Torvalds
 */
 
#include <asm/system.h>
 
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/head.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/malloc.h>
#include <linux/mm.h>
 
#include <asm/segment.h>
#include <asm/pgtable.h>
 
struct vm_struct {
        unsigned long flags;
        void * addr;
        unsigned long size;
        struct vm_struct * next;
};
 
static struct vm_struct * vmlist = NULL;
 
static inline void set_pgdir(unsigned long address, pgd_t entry)
{
        struct task_struct * p;
 
        for_each_task(p) {
                if (!p->mm)
                        continue;
                *pgd_offset(p->mm,address) = entry;
        }
}
 
static inline void free_area_pte(pmd_t * pmd, unsigned long address, unsigned long size)
{
        pte_t * pte;
        unsigned long end;
 
        if (pmd_none(*pmd))
                return;
        if (pmd_bad(*pmd)) {
                printk("free_area_pte: bad pmd (%08lx)\n", pmd_val(*pmd));
                pmd_clear(pmd);
                return;
        }
        pte = pte_offset(pmd, address);
        address &= ~PMD_MASK;
        end = address + size;
        if (end > PMD_SIZE)
                end = PMD_SIZE;
        while (address < end) {
                pte_t page = *pte;
                pte_clear(pte);
                address += PAGE_SIZE;
                pte++;
                if (pte_none(page))
                        continue;
                if (pte_present(page)) {
                        free_page(pte_page(page));
                        continue;
                }
                printk("Whee.. Swapped out page in kernel page table\n");
        }
}
 
static inline void free_area_pmd(pgd_t * dir, unsigned long address, unsigned long size)
{
        pmd_t * pmd;
        unsigned long end;
 
        if (pgd_none(*dir))
                return;
        if (pgd_bad(*dir)) {
                printk("free_area_pmd: bad pgd (%08lx)\n", pgd_val(*dir));
                pgd_clear(dir);
                return;
        }
        pmd = pmd_offset(dir, address);
        address &= ~PGDIR_MASK;
        end = address + size;
        if (end > PGDIR_SIZE)
                end = PGDIR_SIZE;
        while (address < end) {
                free_area_pte(pmd, address, end - address);
                address = (address + PMD_SIZE) & PMD_MASK;
                pmd++;
        }
}
 
static void free_area_pages(unsigned long address, unsigned long size)
{
        pgd_t * dir;
        unsigned long end = address + size;
 
        dir = pgd_offset(&init_mm, address);
        flush_cache_all();
        while (address < end) {
                free_area_pmd(dir, address, end - address);
                address = (address + PGDIR_SIZE) & PGDIR_MASK;
                dir++;
        }
        flush_tlb_all();
}
 
static inline int alloc_area_pte(pte_t * pte, unsigned long address, unsigned long size)
{
        unsigned long end;
 
        address &= ~PMD_MASK;
        end = address + size;
        if (end > PMD_SIZE)
                end = PMD_SIZE;
        while (address < end) {
                unsigned long page;
                if (!pte_none(*pte))
                        printk("alloc_area_pte: page already exists\n");
                page = __get_free_page(GFP_KERNEL);
                if (!page)
                        return -ENOMEM;
                set_pte(pte, mk_pte(page, PAGE_KERNEL));
                address += PAGE_SIZE;
                pte++;
        }
        return 0;
}
 
static inline int alloc_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size)
{
        unsigned long end;
 
        address &= ~PGDIR_MASK;
        end = address + size;
        if (end > PGDIR_SIZE)
                end = PGDIR_SIZE;
        while (address < end) {
                pte_t * pte = pte_alloc_kernel(pmd, address);
                if (!pte)
                        return -ENOMEM;
                if (alloc_area_pte(pte, address, end - address))
                        return -ENOMEM;
                address = (address + PMD_SIZE) & PMD_MASK;
                pmd++;
        }
        return 0;
}
 
static int alloc_area_pages(unsigned long address, unsigned long size)
{
        pgd_t * dir;
        unsigned long end = address + size;
 
        dir = pgd_offset(&init_mm, address);
        flush_cache_all();
        while (address < end) {
                pmd_t *pmd = pmd_alloc_kernel(dir, address);
                if (!pmd)
                        return -ENOMEM;
                if (alloc_area_pmd(pmd, address, end - address))
                        return -ENOMEM;
                set_pgdir(address, *dir);
                address = (address + PGDIR_SIZE) & PGDIR_MASK;
                dir++;
        }
        flush_tlb_all();
        return 0;
}
 
static inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
        unsigned long offset)
{
        unsigned long end;
 
        address &= ~PMD_MASK;
        end = address + size;
        if (end > PMD_SIZE)
                end = PMD_SIZE;
        do {
                if (!pte_none(*pte))
                        printk("remap_area_pte: page already exists\n");
                set_pte(pte, mk_pte(offset, PAGE_KERNEL));
                address += PAGE_SIZE;
                offset += PAGE_SIZE;
                pte++;
        } while (address < end);
}
 
static inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
        unsigned long offset)
{
        unsigned long end;
 
        address &= ~PGDIR_MASK;
        end = address + size;
        if (end > PGDIR_SIZE)
                end = PGDIR_SIZE;
        offset -= address;
        do {
                pte_t * pte = pte_alloc_kernel(pmd, address);
                if (!pte)
                        return -ENOMEM;
                remap_area_pte(pte, address, end - address, address + offset);
                address = (address + PMD_SIZE) & PMD_MASK;
                pmd++;
        } while (address < end);
        return 0;
}
 
static int remap_area_pages(unsigned long address, unsigned long offset, unsigned long size)
{
        pgd_t * dir;
        unsigned long end = address + size;
 
        offset -= address;
        dir = pgd_offset(&init_mm, address);
        flush_cache_all();
        while (address < end) {
                pmd_t *pmd = pmd_alloc_kernel(dir, address);
                if (!pmd)
                        return -ENOMEM;
                if (remap_area_pmd(pmd, address, end - address, offset + address))
                        return -ENOMEM;
                set_pgdir(address, *dir);
                address = (address + PGDIR_SIZE) & PGDIR_MASK;
                dir++;
        }
        flush_tlb_all();
        return 0;
}
 
static struct vm_struct * get_vm_area(unsigned long size)
{
        void *addr;
        struct vm_struct **p, *tmp, *area;
 
        area = (struct vm_struct *) kmalloc(sizeof(*area), GFP_KERNEL);
        if (!area)
                return NULL;
        addr = (void *) VMALLOC_START;
        area->size = size + PAGE_SIZE;
        area->next = NULL;
        for (p = &vmlist; (tmp = *p) ; p = &tmp->next) {
                if (size + (unsigned long) addr < (unsigned long) tmp->addr)
                        break;
                addr = (void *) (tmp->size + (unsigned long) tmp->addr);
        }
        area->addr = addr;
        area->next = *p;
        *p = area;
        return area;
}
 
void vfree(void * addr)
{
        struct vm_struct **p, *tmp;
 
        if (!addr)
                return;
        if ((PAGE_SIZE-1) & (unsigned long) addr) {
                printk("Trying to vfree() bad address (%p)\n", addr);
                return;
        }
        for (p = &vmlist ; (tmp = *p) ; p = &tmp->next) {
                if (tmp->addr == addr) {
                        *p = tmp->next;
                        free_area_pages(VMALLOC_VMADDR(tmp->addr), tmp->size);
                        kfree(tmp);
                        return;
                }
        }
        printk("Trying to vfree() nonexistent vm area (%p)\n", addr);
}
 
void * vmalloc(unsigned long size)
{
        void * addr;
        struct vm_struct *area;
 
        size = PAGE_ALIGN(size);
        if (!size || size > (MAP_NR(high_memory) << PAGE_SHIFT))
                return NULL;
        area = get_vm_area(size);
        if (!area)
                return NULL;
        addr = area->addr;
        if (alloc_area_pages(VMALLOC_VMADDR(addr), size)) {
                vfree(addr);
                return NULL;
        }
        return addr;
}
 
/*
 * Remap an arbitrary physical address space into the kernel virtual
 * address space. Needed when the kernel wants to access high addresses
 * directly.
 */
void * vremap(unsigned long offset, unsigned long size)
{
        void * addr;
        struct vm_struct * area;
 
        if (MAP_NR(offset) < MAP_NR(high_memory))
                return NULL;
        if (offset & ~PAGE_MASK)
                return NULL;
        size = PAGE_ALIGN(size);
        if (!size || size > offset + size)
                return NULL;
        area = get_vm_area(size);
        if (!area)
                return NULL;
        addr = area->addr;
        if (remap_area_pages(VMALLOC_VMADDR(addr), offset, size)) {
                vfree(addr);
                return NULL;
        }
        return addr;
}
 
int vread(char *buf, char *addr, int count)
{
        struct vm_struct **p, *tmp;
        char *vaddr, *buf_start = buf;
        int n;
 
        for (p = &vmlist; (tmp = *p) ; p = &tmp->next) {
                vaddr = (char *) tmp->addr;
                while (addr < vaddr) {
                        if (count == 0)
                                goto finished;
                        put_user('\0', buf++), addr++, count--;
                }
                n = tmp->size - PAGE_SIZE;
                if (addr > vaddr)
                        n -= addr - vaddr;
                while (--n >= 0) {
                        if (count == 0)
                                goto finished;
                        put_user(*addr++, buf++), count--;
                }
        }
finished:
        return buf - buf_start;
}

Browse

Tools

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [mm/] [vmalloc.c] - Blame information for rev 1782

Line No.	Rev	Author	Line
1	1634	jcastillo	`/*`
2			`* linux/mm/vmalloc.c`
3			`*`
4			`* Copyright (C) 1993 Linus Torvalds`
5			`*/`
6
7			`#include <asm/system.h>`
8
9			`#include <linux/signal.h>`
10			`#include <linux/sched.h>`
11			`#include <linux/head.h>`
12			`#include <linux/kernel.h>`
13			`#include <linux/errno.h>`
14			`#include <linux/types.h>`
15			`#include <linux/malloc.h>`
16			`#include <linux/mm.h>`
17
18			`#include <asm/segment.h>`
19			`#include <asm/pgtable.h>`
20
21			`struct vm_struct {`
22			`unsigned long flags;`
23			`void * addr;`
24			`unsigned long size;`
25			`struct vm_struct * next;`
26			`};`
27
28			`static struct vm_struct * vmlist = NULL;`
29
30			`static inline void set_pgdir(unsigned long address, pgd_t entry)`
31			`{`
32			`struct task_struct * p;`
33
34			`for_each_task(p) {`
35			`if (!p->mm)`
36			`continue;`
37			`*pgd_offset(p->mm,address) = entry;`
38			`}`
39			`}`
40
41			`static inline void free_area_pte(pmd_t * pmd, unsigned long address, unsigned long size)`
42			`{`
43			`pte_t * pte;`
44			`unsigned long end;`
45
46			`if (pmd_none(*pmd))`
47			`return;`
48			`if (pmd_bad(*pmd)) {`
49			`printk("free_area_pte: bad pmd (%08lx)\n", pmd_val(*pmd));`
50			`pmd_clear(pmd);`
51			`return;`
52			`}`
53			`pte = pte_offset(pmd, address);`
54			`address &= ~PMD_MASK;`
55			`end = address + size;`
56			`if (end > PMD_SIZE)`
57			`end = PMD_SIZE;`
58			`while (address < end) {`
59			`pte_t page = *pte;`
60			`pte_clear(pte);`
61			`address += PAGE_SIZE;`
62			`pte++;`
63			`if (pte_none(page))`
64			`continue;`
65			`if (pte_present(page)) {`
66			`free_page(pte_page(page));`
67			`continue;`
68			`}`
69			`printk("Whee.. Swapped out page in kernel page table\n");`
70			`}`
71			`}`
72
73			`static inline void free_area_pmd(pgd_t * dir, unsigned long address, unsigned long size)`
74			`{`
75			`pmd_t * pmd;`
76			`unsigned long end;`
77
78			`if (pgd_none(*dir))`
79			`return;`
80			`if (pgd_bad(*dir)) {`
81			`printk("free_area_pmd: bad pgd (%08lx)\n", pgd_val(*dir));`
82			`pgd_clear(dir);`
83			`return;`
84			`}`
85			`pmd = pmd_offset(dir, address);`
86			`address &= ~PGDIR_MASK;`
87			`end = address + size;`
88			`if (end > PGDIR_SIZE)`
89			`end = PGDIR_SIZE;`
90			`while (address < end) {`
91			`free_area_pte(pmd, address, end - address);`
92			`address = (address + PMD_SIZE) & PMD_MASK;`
93			`pmd++;`
94			`}`
95			`}`
96
97			`static void free_area_pages(unsigned long address, unsigned long size)`
98			`{`
99			`pgd_t * dir;`
100			`unsigned long end = address + size;`
101
102			`dir = pgd_offset(&init_mm, address);`
103			`flush_cache_all();`
104			`while (address < end) {`
105			`free_area_pmd(dir, address, end - address);`
106			`address = (address + PGDIR_SIZE) & PGDIR_MASK;`
107			`dir++;`
108			`}`
109			`flush_tlb_all();`
110			`}`
111
112			`static inline int alloc_area_pte(pte_t * pte, unsigned long address, unsigned long size)`
113			`{`
114			`unsigned long end;`
115
116			`address &= ~PMD_MASK;`
117			`end = address + size;`
118			`if (end > PMD_SIZE)`
119			`end = PMD_SIZE;`
120			`while (address < end) {`
121			`unsigned long page;`
122			`if (!pte_none(*pte))`
123			`printk("alloc_area_pte: page already exists\n");`
124			`page = __get_free_page(GFP_KERNEL);`
125			`if (!page)`
126			`return -ENOMEM;`
127			`set_pte(pte, mk_pte(page, PAGE_KERNEL));`
128			`address += PAGE_SIZE;`
129			`pte++;`
130			`}`
131			`return 0;`
132			`}`
133
134			`static inline int alloc_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size)`
135			`{`
136			`unsigned long end;`
137
138			`address &= ~PGDIR_MASK;`
139			`end = address + size;`
140			`if (end > PGDIR_SIZE)`
141			`end = PGDIR_SIZE;`
142			`while (address < end) {`
143			`pte_t * pte = pte_alloc_kernel(pmd, address);`
144			`if (!pte)`
145			`return -ENOMEM;`
146			`if (alloc_area_pte(pte, address, end - address))`
147			`return -ENOMEM;`
148			`address = (address + PMD_SIZE) & PMD_MASK;`
149			`pmd++;`
150			`}`
151			`return 0;`
152			`}`
153
154			`static int alloc_area_pages(unsigned long address, unsigned long size)`
155			`{`
156			`pgd_t * dir;`
157			`unsigned long end = address + size;`
158
159			`dir = pgd_offset(&init_mm, address);`
160			`flush_cache_all();`
161			`while (address < end) {`
162			`pmd_t *pmd = pmd_alloc_kernel(dir, address);`
163			`if (!pmd)`
164			`return -ENOMEM;`
165			`if (alloc_area_pmd(pmd, address, end - address))`
166			`return -ENOMEM;`
167			`set_pgdir(address, *dir);`
168			`address = (address + PGDIR_SIZE) & PGDIR_MASK;`
169			`dir++;`
170			`}`
171			`flush_tlb_all();`
172			`return 0;`
173			`}`
174
175			`static inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,`
176			`unsigned long offset)`
177			`{`
178			`unsigned long end;`
179
180			`address &= ~PMD_MASK;`
181			`end = address + size;`
182			`if (end > PMD_SIZE)`
183			`end = PMD_SIZE;`
184			`do {`
185			`if (!pte_none(*pte))`
186			`printk("remap_area_pte: page already exists\n");`
187			`set_pte(pte, mk_pte(offset, PAGE_KERNEL));`
188			`address += PAGE_SIZE;`
189			`offset += PAGE_SIZE;`
190			`pte++;`
191			`} while (address < end);`
192			`}`
193
194			`static inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,`
195			`unsigned long offset)`
196			`{`
197			`unsigned long end;`
198
199			`address &= ~PGDIR_MASK;`
200			`end = address + size;`
201			`if (end > PGDIR_SIZE)`
202			`end = PGDIR_SIZE;`
203			`offset -= address;`
204			`do {`
205			`pte_t * pte = pte_alloc_kernel(pmd, address);`
206			`if (!pte)`
207			`return -ENOMEM;`
208			`remap_area_pte(pte, address, end - address, address + offset);`
209			`address = (address + PMD_SIZE) & PMD_MASK;`
210			`pmd++;`
211			`} while (address < end);`
212			`return 0;`
213			`}`
214
215			`static int remap_area_pages(unsigned long address, unsigned long offset, unsigned long size)`
216			`{`
217			`pgd_t * dir;`
218			`unsigned long end = address + size;`
219
220			`offset -= address;`
221			`dir = pgd_offset(&init_mm, address);`
222			`flush_cache_all();`
223			`while (address < end) {`
224			`pmd_t *pmd = pmd_alloc_kernel(dir, address);`
225			`if (!pmd)`
226			`return -ENOMEM;`
227			`if (remap_area_pmd(pmd, address, end - address, offset + address))`
228			`return -ENOMEM;`
229			`set_pgdir(address, *dir);`
230			`address = (address + PGDIR_SIZE) & PGDIR_MASK;`
231			`dir++;`
232			`}`
233			`flush_tlb_all();`
234			`return 0;`
235			`}`
236
237			`static struct vm_struct * get_vm_area(unsigned long size)`
238			`{`
239			`void *addr;`
240			`struct vm_struct *p, tmp, *area;`
241
242			`area = (struct vm_struct ) kmalloc(sizeof(area), GFP_KERNEL);`
243			`if (!area)`
244			`return NULL;`
245			`addr = (void *) VMALLOC_START;`
246			`area->size = size + PAGE_SIZE;`
247			`area->next = NULL;`
248			`for (p = &vmlist; (tmp = *p) ; p = &tmp->next) {`
249			`if (size + (unsigned long) addr < (unsigned long) tmp->addr)`
250			`break;`
251			`addr = (void *) (tmp->size + (unsigned long) tmp->addr);`
252			`}`
253			`area->addr = addr;`
254			`area->next = *p;`
255			`*p = area;`
256			`return area;`
257			`}`
258
259			`void vfree(void * addr)`
260			`{`
261			`struct vm_struct *p, tmp;`
262
263			`if (!addr)`
264			`return;`
265			`if ((PAGE_SIZE-1) & (unsigned long) addr) {`
266			`printk("Trying to vfree() bad address (%p)\n", addr);`
267			`return;`
268			`}`
269			`for (p = &vmlist ; (tmp = *p) ; p = &tmp->next) {`
270			`if (tmp->addr == addr) {`
271			`*p = tmp->next;`
272			`free_area_pages(VMALLOC_VMADDR(tmp->addr), tmp->size);`
273			`kfree(tmp);`
274			`return;`
275			`}`
276			`}`
277			`printk("Trying to vfree() nonexistent vm area (%p)\n", addr);`
278			`}`
279
280			`void * vmalloc(unsigned long size)`
281			`{`
282			`void * addr;`
283			`struct vm_struct *area;`
284
285			`size = PAGE_ALIGN(size);`
286			`if (!size \|\| size > (MAP_NR(high_memory) << PAGE_SHIFT))`
287			`return NULL;`
288			`area = get_vm_area(size);`
289			`if (!area)`
290			`return NULL;`
291			`addr = area->addr;`
292			`if (alloc_area_pages(VMALLOC_VMADDR(addr), size)) {`
293			`vfree(addr);`
294			`return NULL;`
295			`}`
296			`return addr;`
297			`}`
298
299			`/*`
300			`* Remap an arbitrary physical address space into the kernel virtual`
301			`* address space. Needed when the kernel wants to access high addresses`
302			`* directly.`
303			`*/`
304			`void * vremap(unsigned long offset, unsigned long size)`
305			`{`
306			`void * addr;`
307			`struct vm_struct * area;`
308
309			`if (MAP_NR(offset) < MAP_NR(high_memory))`
310			`return NULL;`
311			`if (offset & ~PAGE_MASK)`
312			`return NULL;`
313			`size = PAGE_ALIGN(size);`
314			`if (!size \|\| size > offset + size)`
315			`return NULL;`
316			`area = get_vm_area(size);`
317			`if (!area)`
318			`return NULL;`
319			`addr = area->addr;`
320			`if (remap_area_pages(VMALLOC_VMADDR(addr), offset, size)) {`
321			`vfree(addr);`
322			`return NULL;`
323			`}`
324			`return addr;`
325			`}`
326
327			`int vread(char buf, char addr, int count)`
328			`{`
329			`struct vm_struct *p, tmp;`
330			`char vaddr, buf_start = buf;`
331			`int n;`
332
333			`for (p = &vmlist; (tmp = *p) ; p = &tmp->next) {`
334			`vaddr = (char *) tmp->addr;`
335			`while (addr < vaddr) {`
336			`if (count == 0)`
337			`goto finished;`
338			`put_user('\0', buf++), addr++, count--;`
339			`}`
340			`n = tmp->size - PAGE_SIZE;`
341			`if (addr > vaddr)`
342			`n -= addr - vaddr;`
343			`while (--n >= 0) {`
344			`if (count == 0)`
345			`goto finished;`
346			`put_user(*addr++, buf++), count--;`
347			`}`
348			`}`
349			`finished:`
350			`return buf - buf_start;`
351			`}`