Subversion Repositories HelenOS-historic

Rev

Rev 102 | Rev 115 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 102 Rev 113
Line 46... Line 46...
46 
count_t frames_free;
 46 
count_t frames_free;
47 
 
 47 
 
48 
__u8 *frame_bitmap;
 48 
__u8 *frame_bitmap;
49 
count_t frame_bitmap_octets;
 49 
count_t frame_bitmap_octets;
50 
 
 50 
 
51 
/*
 - 
 
52 
 * This is for kernel address space frames (allocated with FRAME_KA).
 - 
 
53 
 * Their addresses may not interfere with user address space.
 - 
 
54 
 */
 - 
 
55 
__u8 *frame_kernel_bitmap;
 - 
 
56 
count_t kernel_frames;
 - 
 
57 
count_t kernel_frames_free;
 - 
 
58 
 
 - 
 
59 
static spinlock_t framelock;
 51 
static spinlock_t framelock;
60 
 
 52 
 
61 
void frame_init(void)
 53 
void frame_init(void)
62 
{
 54 
{
63 
        if (config.cpu_active == 1) {
 55 
        if (config.cpu_active == 1) {
Line 75... Line 67...
75 
                /*
 67 
                /*
76 
                 * Mark all frames free.
 68 
                 * Mark all frames free.
77 
                 */
 69 
                 */
78 
                memsetb((__address) frame_bitmap, frame_bitmap_octets, 0);
 70 
                memsetb((__address) frame_bitmap, frame_bitmap_octets, 0);
79 
                frames_free = frames;
 71 
                frames_free = frames;
80 
 
 - 
 
81 
        /*
 - 
 
82 
         * Will be properly set up by architecture dependent frame init.
 - 
 
83 
         */
 - 
 
84 
        frame_kernel_bitmap = NULL;
 - 
 
85 
        kernel_frames_free = 0;
 - 
 
86 
        kernel_frames = 0; 
 - 
 
87 
    }
 72 
    }
88 
 
 73 
 
89 
    /*
 74 
    /*
90 
     * No frame allocations/reservations  prior this point.
 75 
     * No frame allocations/reservations prior this point.
91 
     */
 76 
     */
92 
 
 77 
 
93 
    frame_arch_init();
 78 
    frame_arch_init();
94 
 
 79 
 
95 
    if (config.cpu_active == 1) {
 80 
    if (config.cpu_active == 1) {
Line 106... Line 91...
106 
 */
 91 
 */
107 
__address frame_alloc(int flags)
 92 
__address frame_alloc(int flags)
108 
{
 93 
{
109 
    int i;
 94 
    int i;
110 
    pri_t pri;
 95 
    pri_t pri;
111 
    __u8 **frame_bitmap_ptr = &frame_bitmap;
 - 
 
112 
    count_t *frames_ptr = &frames, *frames_free_ptr = &frames_free;
 - 
 
113 
   
 - 
 
114 
    if (flags & FRAME_KA) {
 - 
 
115 
        frame_bitmap_ptr = &frame_kernel_bitmap;
 - 
 
116 
        frames_ptr = &kernel_frames;
 - 
 
117 
        frames_free_ptr = &kernel_frames_free;
 - 
 
118 
    }
 - 
 
119 
   
 96 
   
120 
loop:
 97 
loop:
121 
    pri = cpu_priority_high();
 98 
    pri = cpu_priority_high();
122 
    spinlock_lock(&framelock);
 99 
    spinlock_lock(&framelock);
123 
    if (*frames_free_ptr) {
 100 
    if (frames_free) {
124 
        for (i=0; i < *frames_ptr; i++) {
 101 
        for (i=0; i < frames; i++) {
125 
            int m, n;
 102 
            int m, n;
126 
       
 103 
       
127 
            m = i / 8;
 104 
            m = i / 8;
128 
            n = i % 8;
 105 
            n = i % 8;
129 
 
 106 
 
130 
            if (((*frame_bitmap_ptr)[m] & (1<<n)) == 0) {
 107 
            if ((frame_bitmap[m] & (1<<n)) == 0) {
131 
                (*frame_bitmap_ptr)[m] |= (1<<n);
 108 
                frame_bitmap[m] |= (1<<n);
132 
                *frames_free_ptr--;
 - 
 
133 
                if (flags & FRAME_KA) {
 - 
 
134 
                    /*
 - 
 
135 
                     * frames_free_ptr points to kernel_frames_free
 - 
 
136 
                     * It is still necessary to decrement frames_free.
 - 
 
137 
                     */
 - 
 
138 
                    frames_free--;
 109 
                frames_free--;
139 
                }
 - 
 
140 
                spinlock_unlock(&framelock);
 110 
                spinlock_unlock(&framelock);
141 
                cpu_priority_restore(pri);
 111 
                cpu_priority_restore(pri);
142 
                if (flags & FRAME_KA) return PA2KA(i*FRAME_SIZE);
 112 
                if (flags & FRAME_KA) return PA2KA(i*FRAME_SIZE);
143 
                return i*FRAME_SIZE;
 113 
                return i*FRAME_SIZE;
144 
            }
 114 
            }
Line 162... Line 132...
162 
 */
 132 
 */
163 
void frame_free(__address addr)
 133 
void frame_free(__address addr)
164 
{
 134 
{
165 
    pri_t pri;
 135 
    pri_t pri;
166 
    __u32 frame;
 136 
    __u32 frame;
167 
    count_t *frames_free_ptr = &frames_free, *frames_ptr = &frames;
 - 
 
168 
    __u8 **frame_bitmap_ptr = &frame_bitmap;
 - 
 
169 
 
 - 
 
170 
    if (IS_KA(addr)) {
 - 
 
171 
        frames_free_ptr = &kernel_frames_free;
 - 
 
172 
        frame_bitmap_ptr = &frame_kernel_bitmap;
 - 
 
173 
    }
 - 
 
174 
 
 137 
 
175 
    pri = cpu_priority_high();
 138 
    pri = cpu_priority_high();
176 
    spinlock_lock(&framelock);
 139 
    spinlock_lock(&framelock);
177 
   
 140 
   
178 
    frame = IS_KA(addr) ? KA2PA(addr) : addr;
 141 
    frame = IS_KA(addr) ? KA2PA(addr) : addr;
179 
    frame /= FRAME_SIZE;
 142 
    frame /= FRAME_SIZE;
180 
    if (frame < *frames_ptr) {
 143 
    if (frame < frames) {
181 
        int m, n;
 144 
        int m, n;
182 
   
 145 
   
183 
        m = frame / 8;
 146 
        m = frame / 8;
184 
        n = frame % 8;
 147 
        n = frame % 8;
185 
   
 148 
   
186 
        if ((*frame_bitmap_ptr)[m] & (1<<n)) {
 149 
        if (frame_bitmap[m] & (1<<n)) {
187 
            (*frame_bitmap_ptr)[m] &= ~(1<<n);
 150 
            frame_bitmap[m] &= ~(1<<n);
188 
            *frames_free_ptr++;
 - 
 
189 
            if (IS_KA(addr)) {
 - 
 
190 
                /*
 - 
 
191 
                 * frames_free_ptr points to kernel_frames_free
 - 
 
192 
                 * It is still necessary to increment frames_free.
 - 
 
193 
                 */
 - 
 
194 
                 frames_free++;
 151 
            frames_free++;
195 
            }  
 - 
 
196 
        }
 152 
        }
197 
        else panic("frame already free\n");
 153 
        else panic("frame already free\n");
198 
    }
 154 
    }
199 
    else panic("frame number too big\n");
 155 
    else panic("frame number too big\n");
200 
   
 156 
   
Line 208... Line 164...
208 
 */
 164 
 */
209 
void frame_not_free(__address addr)
 165 
void frame_not_free(__address addr)
210 
{
 166 
{
211 
    pri_t pri;
 167 
    pri_t pri;
212 
    __u32 frame;
 168 
    __u32 frame;
213 
    count_t *frames_ptr = &frames, *frames_free_ptr = &frames_free;
 - 
 
214 
    __u8 **frame_bitmap_ptr = &frame_bitmap;
 - 
 
215 
   
 169 
   
216 
    pri = cpu_priority_high();
 170 
    pri = cpu_priority_high();
217 
    spinlock_lock(&framelock);
 171 
    spinlock_lock(&framelock);
218 
    frame = IS_KA(addr) ? KA2PA(addr) : addr;
 172 
    frame = IS_KA(addr) ? KA2PA(addr) : addr;
219 
    frame /= FRAME_SIZE;
 173 
    frame /= FRAME_SIZE;
220 
    if (frame < *frames_ptr) {
 174 
    if (frame < frames) {
221 
        int m, n;
 175 
        int m, n;
222 
 
 176 
 
223 
        m = frame / 8;
 177 
        m = frame / 8;
224 
        n = frame % 8;
 178 
        n = frame % 8;
225 
   
 179 
   
226 
        if (((*frame_bitmap_ptr)[m] & (1<<n)) == 0) {  
 180 
        if ((frame_bitmap[m] & (1<<n)) == 0) { 
227 
            (*frame_bitmap_ptr)[m] |= (1<<n);
 181 
            frame_bitmap[m] |= (1<<n);
228 
            *frames_free_ptr--;
 - 
 
229 
            if (IS_KA(addr)) {
 - 
 
230 
                /*
 - 
 
231 
                 * frames_free_ptr points to kernel_frames_free
 - 
 
232 
                 * It is still necessary to decrement frames_free.
 - 
 
233 
                 */
 - 
 
234 
                frames_free--;
 182 
            frames_free--; 
235 
            }
 - 
 
236 
        }
 183 
        }
237 
    }
 184 
    }
238 
    spinlock_unlock(&framelock);
 185 
    spinlock_unlock(&framelock);
239 
    cpu_priority_restore(pri);
 186 
    cpu_priority_restore(pri);
240 
}
 187 
}