Subversion Repositories HelenOS

Rev

Rev 814 | Rev 822 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 jermar 1
/*
564 jermar 2
 * Copyright (C) 2001-2005 Jakub Jermar
3
 * Copyright (C) 2005 Sergey Bondari
1 jermar 4
 * All rights reserved.
5
 *
6
 * Redistribution and use in source and binary forms, with or without
7
 * modification, are permitted provided that the following conditions
8
 * are met:
9
 *
10
 * - Redistributions of source code must retain the above copyright
11
 *   notice, this list of conditions and the following disclaimer.
12
 * - Redistributions in binary form must reproduce the above copyright
13
 *   notice, this list of conditions and the following disclaimer in the
14
 *   documentation and/or other materials provided with the distribution.
15
 * - The name of the author may not be used to endorse or promote products
16
 *   derived from this software without specific prior written permission.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 */
29
 
814 palkovsky 30
/*
31
 * Locking order
32
 *
33
 * In order to access particular zone, the process must first lock
34
 * the zones.lock, then lock the zone and then unlock the zones.lock.
35
 * This insures, that we can fiddle with the zones in runtime without
36
 * affecting the processes.
37
 *
38
 */
39
 
368 jermar 40
#include <typedefs.h>
1 jermar 41
#include <arch/types.h>
42
#include <mm/frame.h>
703 jermar 43
#include <mm/as.h>
1 jermar 44
#include <panic.h>
367 jermar 45
#include <debug.h>
788 jermar 46
#include <adt/list.h>
1 jermar 47
#include <synch/spinlock.h>
115 jermar 48
#include <arch/asm.h>
195 vana 49
#include <arch.h>
533 bondari 50
#include <print.h>
536 bondari 51
#include <align.h>
814 palkovsky 52
#include <mm/slab.h>
115 jermar 53
 
814 palkovsky 54
typedef struct {
55
    count_t refcount;   /**< tracking of shared frames  */
56
    __u8 buddy_order;   /**< buddy system block order */
57
    link_t buddy_link;  /**< link to the next free block inside one order */
58
    void *parent;           /**< If allocated by slab, this points there */
59
}frame_t;
367 jermar 60
 
814 palkovsky 61
typedef struct {
62
    SPINLOCK_DECLARE(lock); /**< this lock protects everything below */
63
    pfn_t base; /**< frame_no of the first frame in the frames array */
820 jermar 64
    count_t count;          /**< Size of zone */
533 bondari 65
 
814 palkovsky 66
    frame_t *frames;    /**< array of frame_t structures in this zone */
67
    count_t free_count; /**< number of free frame_t structures */
68
    count_t busy_count; /**< number of busy frame_t structures */
69
 
70
    buddy_system_t * buddy_system; /**< buddy system for the zone */
71
    int flags;
72
}zone_t;
479 bondari 73
 
814 palkovsky 74
/*
75
 * The zoneinfo.lock must be locked when accessing zoneinfo structure.
76
 * Some of the attributes in zone_t structures are 'read-only'
368 jermar 77
 */
1 jermar 78
 
814 palkovsky 79
struct {
80
    SPINLOCK_DECLARE(lock);
81
    int count;
82
    zone_t *info[ZONES_MAX];
83
}zones;
1 jermar 84
 
814 palkovsky 85
 
86
/*********************************/
87
/* Helper functions */
88
static inline index_t frame_index(zone_t *zone, frame_t *frame)
762 palkovsky 89
{
814 palkovsky 90
    return (index_t)(frame - zone->frames);
762 palkovsky 91
}
814 palkovsky 92
static inline index_t frame_index_abs(zone_t *zone, frame_t *frame)
1 jermar 93
{
814 palkovsky 94
    return (index_t)(frame - zone->frames) + zone->base;
1 jermar 95
}
814 palkovsky 96
static inline int frame_index_valid(zone_t *zone, index_t index)
97
{
98
    return index >= 0 && index < zone->count;
99
}
1 jermar 100
 
814 palkovsky 101
/** Compute pfn_t from frame_t pointer & zone pointer */
820 jermar 102
static index_t make_frame_index(zone_t *zone, frame_t *frame)
762 palkovsky 103
{
814 palkovsky 104
    return frame - zone->frames;
762 palkovsky 105
}
106
 
814 palkovsky 107
/** Initialize frame structure
762 palkovsky 108
 *
814 palkovsky 109
 * Initialize frame structure.
110
 *
111
 * @param frame Frame structure to be initialized.
762 palkovsky 112
 */
814 palkovsky 113
static void frame_initialize(frame_t *frame)
762 palkovsky 114
{
814 palkovsky 115
    frame->refcount = 1;
116
    frame->buddy_order = 0;
762 palkovsky 117
}
118
 
814 palkovsky 119
/*************************************/
120
/* Zoneinfo functions */
762 palkovsky 121
 
814 palkovsky 122
/**
123
 * Insert-sort zone into zones list
1 jermar 124
 */
814 palkovsky 125
static void zones_add_zone(zone_t *zone)
1 jermar 126
{
814 palkovsky 127
    int i;
762 palkovsky 128
 
814 palkovsky 129
    spinlock_lock(&zones.lock);
130
    /* Try to merge */
131
    if (zone->flags & ZONE_JOIN) {
132
        for (i=0; i < zones.count; i++) {
133
            spinlock_lock(&zones.info[i]->lock);
134
 
135
            /* Join forward, join backward */
136
            panic("Not implemented");
533 bondari 137
 
814 palkovsky 138
            spinlock_unlock(&zones.info[i]->lock);
139
        }
140
        spinlock_unlock(&zones.lock);
141
    } else {
142
        if (zones.count+1 == ZONES_MAX)
143
            panic("Maximum zone(%d) count exceeded.", ZONES_MAX);
144
        zones.info[zones.count++] = zone;
368 jermar 145
    }
814 palkovsky 146
    spinlock_unlock(&zones.lock);
1 jermar 147
}
148
 
814 palkovsky 149
/**
150
 * Try to find a zone where can we find the frame
368 jermar 151
 *
814 palkovsky 152
 * @param hint Start searching in zone 'hint'
153
 * @param lock Lock zone if true
368 jermar 154
 *
814 palkovsky 155
 * Assume interrupts disable
368 jermar 156
 */
814 palkovsky 157
static zone_t * find_zone_and_lock(pfn_t frame, int *pzone)
1 jermar 158
{
533 bondari 159
    int i;
814 palkovsky 160
    int hint = pzone ? *pzone : 0;
161
    zone_t *z;
533 bondari 162
 
814 palkovsky 163
    spinlock_lock(&zones.lock);
164
 
165
    if (hint >= zones.count || hint < 0)
166
        hint = 0;
533 bondari 167
 
814 palkovsky 168
    i = hint;
169
    do {
170
        z = zones.info[i];
171
        spinlock_lock(&z->lock);
172
        if (z->base <= frame && z->base + z->count > frame) {
173
            spinlock_unlock(&zones.lock); /* Unlock the global lock */
174
            if (pzone)
175
                *pzone = i;
176
            return z;
533 bondari 177
        }
814 palkovsky 178
        spinlock_unlock(&z->lock);
533 bondari 179
 
814 palkovsky 180
        i++;
181
        if (i >= zones.count)
182
            i = 0;
183
    } while(i != hint);
184
 
185
    spinlock_unlock(&zones.lock);
186
    return NULL;
533 bondari 187
}
188
 
814 palkovsky 189
/**
190
 * Find AND LOCK zone that can allocate order frames
367 jermar 191
 *
814 palkovsky 192
 * Assume interrupts are disabled!!
367 jermar 193
 *
814 palkovsky 194
 * @param pzone Pointer to preferred zone or NULL, on return contains zone number
367 jermar 195
 */
814 palkovsky 196
static zone_t * find_free_zone_lock(__u8 order, int *pzone)
367 jermar 197
{
814 palkovsky 198
    int i;
367 jermar 199
    zone_t *z;
814 palkovsky 200
    int hint = pzone ? *pzone : 0;
367 jermar 201
 
814 palkovsky 202
    spinlock_lock(&zones.lock);
203
    if (hint >= zones.count)
204
        hint = 0;
205
    i = hint;
206
    do {
207
        z = zones.info[i];
724 palkovsky 208
 
814 palkovsky 209
        spinlock_lock(&z->lock);
367 jermar 210
 
814 palkovsky 211
        /* Check if the zone has 2^order frames area available  */
212
        if (buddy_system_can_alloc(z->buddy_system, order)) {
213
            spinlock_unlock(&zones.lock);
214
            if (pzone)
215
                *pzone = i;
216
            return z;
367 jermar 217
        }
814 palkovsky 218
        spinlock_unlock(&z->lock);
219
        if (++i >= zones.count)
220
            i = 0;
221
    } while(i != hint);
222
    spinlock_unlock(&zones.lock);
223
    return NULL;
367 jermar 224
}
225
 
814 palkovsky 226
/********************************************/
227
/* Buddy system functions */
228
 
229
/** Buddy system find_block implementation
367 jermar 230
 *
814 palkovsky 231
 * Find block that is parent of current list.
232
 * That means go to lower addresses, until such block is found
367 jermar 233
 *
814 palkovsky 234
 * @param order - Order of parent must be different then this parameter!!
367 jermar 235
 */
814 palkovsky 236
static link_t *zone_buddy_find_block(buddy_system_t *b, link_t *child,
237
                     __u8 order)
367 jermar 238
{
814 palkovsky 239
    frame_t * frame;
240
    zone_t * zone;
241
    index_t index;
367 jermar 242
 
814 palkovsky 243
    frame = list_get_instance(child, frame_t, buddy_link);
244
    zone = (zone_t *) b->data;
367 jermar 245
 
814 palkovsky 246
    index = frame_index(zone, frame);
247
    do {
248
        if (zone->frames[index].buddy_order != order) {
249
            return &zone->frames[index].buddy_link;
250
        }
251
    } while(index-- > 0);
252
    return NULL;
367 jermar 253
}
479 bondari 254
 
814 palkovsky 255
 
479 bondari 256
 
257
/** Buddy system find_buddy implementation
489 jermar 258
 *
259
 * @param b Buddy system.
480 bondari 260
 * @param block Block for which buddy should be found
479 bondari 261
 *
480 bondari 262
 * @return Buddy for given block if found
479 bondari 263
 */
814 palkovsky 264
static link_t * zone_buddy_find_buddy(buddy_system_t *b, link_t * block)
265
{
539 jermar 266
    frame_t * frame;
480 bondari 267
    zone_t * zone;
564 jermar 268
    index_t index;
480 bondari 269
    bool is_left, is_right;
479 bondari 270
 
480 bondari 271
    frame = list_get_instance(block, frame_t, buddy_link);
533 bondari 272
    zone = (zone_t *) b->data;
814 palkovsky 273
    ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame), frame->buddy_order));
480 bondari 274
 
724 palkovsky 275
    is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
276
    is_right = IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame);
814 palkovsky 277
 
564 jermar 278
    ASSERT(is_left ^ is_right);
533 bondari 279
    if (is_left) {
814 palkovsky 280
        index = (frame_index(zone, frame)) + (1 << frame->buddy_order);
615 palkovsky 281
    } else { // if (is_right)
814 palkovsky 282
        index = (frame_index(zone, frame)) - (1 << frame->buddy_order);
533 bondari 283
    }
284
 
814 palkovsky 285
 
286
    if (frame_index_valid(zone, index)) {
287
        if (zone->frames[index].buddy_order == frame->buddy_order &&
288
            zone->frames[index].refcount == 0) {
533 bondari 289
            return &zone->frames[index].buddy_link;
480 bondari 290
        }
291
    }
814 palkovsky 292
 
539 jermar 293
    return NULL;   
479 bondari 294
}
295
 
296
/** Buddy system bisect implementation
297
 *
489 jermar 298
 * @param b Buddy system.
480 bondari 299
 * @param block Block to bisect
300
 *
301
 * @return right block
479 bondari 302
 */
814 palkovsky 303
static link_t * zone_buddy_bisect(buddy_system_t *b, link_t * block) {
480 bondari 304
    frame_t * frame_l, * frame_r;
564 jermar 305
 
480 bondari 306
    frame_l = list_get_instance(block, frame_t, buddy_link);
533 bondari 307
    frame_r = (frame_l + (1 << (frame_l->buddy_order - 1)));
564 jermar 308
 
480 bondari 309
    return &frame_r->buddy_link;
479 bondari 310
}
311
 
312
/** Buddy system coalesce implementation
313
 *
489 jermar 314
 * @param b Buddy system.
480 bondari 315
 * @param block_1 First block
316
 * @param block_2 First block's buddy
317
 *
318
 * @return Coalesced block (actually block that represents lower address)
479 bondari 319
 */
814 palkovsky 320
static link_t * zone_buddy_coalesce(buddy_system_t *b, link_t * block_1,
321
                    link_t * block_2) {
322
    frame_t *frame1, *frame2;
564 jermar 323
 
480 bondari 324
    frame1 = list_get_instance(block_1, frame_t, buddy_link);
325
    frame2 = list_get_instance(block_2, frame_t, buddy_link);
564 jermar 326
 
533 bondari 327
    return frame1 < frame2 ? block_1 : block_2;
479 bondari 328
}
329
 
330
/** Buddy system set_order implementation
489 jermar 331
 *
332
 * @param b Buddy system.
480 bondari 333
 * @param block Buddy system block
334
 * @param order Order to set
479 bondari 335
 */
814 palkovsky 336
static void zone_buddy_set_order(buddy_system_t *b, link_t * block, __u8 order) {
480 bondari 337
    frame_t * frame;
338
    frame = list_get_instance(block, frame_t, buddy_link);
339
    frame->buddy_order = order;
479 bondari 340
}
341
 
342
/** Buddy system get_order implementation
489 jermar 343
 *
344
 * @param b Buddy system.
480 bondari 345
 * @param block Buddy system block
479 bondari 346
 *
480 bondari 347
 * @return Order of block
479 bondari 348
 */
814 palkovsky 349
static __u8 zone_buddy_get_order(buddy_system_t *b, link_t * block) {
480 bondari 350
    frame_t * frame;
351
    frame = list_get_instance(block, frame_t, buddy_link);
352
    return frame->buddy_order;
479 bondari 353
}
533 bondari 354
 
355
/** Buddy system mark_busy implementation
356
 *
357
 * @param b Buddy system
358
 * @param block Buddy system block
359
 *
360
 */
814 palkovsky 361
static void zone_buddy_mark_busy(buddy_system_t *b, link_t * block) {
533 bondari 362
    frame_t * frame;
363
    frame = list_get_instance(block, frame_t, buddy_link);
364
    frame->refcount = 1;
365
}
676 bondari 366
 
814 palkovsky 367
/** Buddy system mark_available implementation
368
 *
369
 * @param b Buddy system
370
 * @param block Buddy system block
371
 *
372
 */
373
static void zone_buddy_mark_available(buddy_system_t *b, link_t * block) {
374
    frame_t * frame;
375
    frame = list_get_instance(block, frame_t, buddy_link);
376
    frame->refcount = 0;
377
}
378
 
379
static struct buddy_system_operations  zone_buddy_system_operations = {
380
    .find_buddy = zone_buddy_find_buddy,
381
    .bisect = zone_buddy_bisect,
382
    .coalesce = zone_buddy_coalesce,
383
    .set_order = zone_buddy_set_order,
384
    .get_order = zone_buddy_get_order,
385
    .mark_busy = zone_buddy_mark_busy,
386
    .mark_available = zone_buddy_mark_available,
387
    .find_block = zone_buddy_find_block
388
};
389
 
390
/*************************************/
391
/* Zone functions */
392
 
393
/** Allocate frame in particular zone
394
 *
395
 * Assume zone is locked
396
 *
397
 * @return Frame index in zone
398
 */
399
static pfn_t zone_frame_alloc(zone_t *zone,__u8 order, int flags, int *status)
400
{
401
    pfn_t v;
402
    link_t *tmp;
403
    frame_t *frame;
404
 
405
    /* Allocate frames from zone buddy system */
406
    tmp = buddy_system_alloc(zone->buddy_system, order);
407
 
408
    ASSERT(tmp);
409
 
410
    /* Update zone information. */
411
    zone->free_count -= (1 << order);
412
    zone->busy_count += (1 << order);
413
 
414
    /* Frame will be actually a first frame of the block. */
415
    frame = list_get_instance(tmp, frame_t, buddy_link);
416
 
417
    /* get frame address */
418
    v = make_frame_index(zone, frame);
419
    return v;
420
}
421
 
422
/** Free frame from zone
423
 *
424
 * Assume zone is locked
425
 */
820 jermar 426
static void zone_frame_free(zone_t *zone, index_t frame_idx)
814 palkovsky 427
{
428
    frame_t *frame;
429
    __u8 order;
430
 
431
    frame = &zone->frames[frame_idx];
432
 
433
    /* remember frame order */
434
    order = frame->buddy_order;
435
 
436
    ASSERT(frame->refcount);
437
 
438
    if (!--frame->refcount) {
439
        buddy_system_free(zone->buddy_system, &frame->buddy_link);
440
    }
441
 
442
    /* Update zone information. */
443
    zone->free_count += (1 << order);
444
    zone->busy_count -= (1 << order);
445
}
446
 
447
/** Return frame from zone */
820 jermar 448
static frame_t * zone_get_frame(zone_t *zone, index_t frame_idx)
814 palkovsky 449
{
450
    ASSERT(frame_idx < zone->count);
451
    return &zone->frames[frame_idx];
452
}
453
 
454
/** Mark frame in zone unavailable to allocation */
820 jermar 455
static void zone_mark_unavailable(zone_t *zone, index_t frame_idx)
814 palkovsky 456
{
457
    frame_t *frame;
458
    link_t *link;
459
 
460
    frame = zone_get_frame(zone, frame_idx);
461
    link = buddy_system_alloc_block(zone->buddy_system,
462
                    &frame->buddy_link);
463
    ASSERT(link);
464
    zone->free_count--;
465
}
466
 
467
/** Create frame zone
468
 *
469
 * Create new frame zone.
470
 *
471
 * @param start Physical address of the first frame within the zone.
472
 * @param size Size of the zone. Must be a multiple of FRAME_SIZE.
473
 * @param conffram Address of configuration frame
474
 * @param flags Zone flags.
475
 *
476
 * @return Initialized zone.
477
 */
820 jermar 478
static zone_t * zone_construct(pfn_t start, count_t count,
814 palkovsky 479
                   zone_t *z, int flags)
480
{
481
    int i;
482
    __u8 max_order;
483
 
484
    spinlock_initialize(&z->lock, "zone_lock");
485
    z->base = start;
486
    z->count = count;
487
    z->flags = flags;
488
    z->free_count = count;
489
    z->busy_count = 0;
490
 
491
    /*
492
     * Compute order for buddy system, initialize
493
     */
494
    for (max_order = 0; count >> max_order; max_order++)
495
        ;
496
    z->buddy_system = (buddy_system_t *)&z[1];
497
 
498
    buddy_system_create(z->buddy_system, max_order,
499
                &zone_buddy_system_operations,
500
                (void *) z);
501
 
502
    /* Allocate frames _after_ the conframe */
503
    /* Check sizes */
504
    z->frames = (frame_t *)((void *)z->buddy_system+buddy_conf_size(max_order));
505
 
506
    for (i = 0; i<count; i++) {
507
        frame_initialize(&z->frames[i]);
508
    }
509
    /* Stuffing frames */
510
    for (i = 0; i < count; i++) {
511
        z->frames[i].refcount = 0;
512
        buddy_system_free(z->buddy_system, &z->frames[i].buddy_link);
513
    }
514
    return z;
515
}
516
 
517
 
518
/** Compute configuration data size for zone */
820 jermar 519
__address zone_conf_size(pfn_t start, count_t count)
814 palkovsky 520
{
521
    int size = sizeof(zone_t) + count*sizeof(frame_t);
522
    int max_order;
523
 
524
    for (max_order = 0; count >> max_order; max_order++)
525
        ;
526
    size += buddy_conf_size(max_order);
527
    return size;
528
}
529
 
530
/** Create and add zone to system
531
 *
532
 * @param confframe Where configuration frame is supposed to be.
820 jermar 533
 *                  Always check, that we will not disturb the kernel and possibly init.
814 palkovsky 534
 *                  If confframe is given _outside_ this zone, it is expected,
535
 *                  that the area is already marked BUSY and big enough
536
 *                  to contain zone_conf_size() amount of data
537
 */
820 jermar 538
void zone_create(pfn_t start, count_t count, pfn_t confframe, int flags)
814 palkovsky 539
{
540
    zone_t *z;
541
    __address addr,endaddr;
820 jermar 542
    count_t confcount;
814 palkovsky 543
    int i;
544
 
545
    /* Theoretically we could have here 0, practically make sure
546
     * nobody tries to do that. If some platform requires, remove
547
     * the assert
548
     */
549
    ASSERT(confframe);
550
    /* If conframe is supposed to be inside our zone, then make sure
551
     * it does not span kernel & init
552
     */
820 jermar 553
    confcount = SIZE2FRAMES(zone_conf_size(start,count));
814 palkovsky 554
    if (confframe >= start && confframe < start+count) {
555
        for (;confframe < start+count;confframe++) {
556
            addr = PFN2ADDR(confframe);
557
            endaddr =  PFN2ADDR (confframe + confcount);
558
            if (overlaps(addr, endaddr, KA2PA(config.base),
559
                     KA2PA(config.base+config.kernel_size)))
560
                continue;
561
            if (config.init_addr)
562
                if (overlaps(addr,endaddr,
563
                         KA2PA(config.init_addr),
564
                         KA2PA(config.init_addr+config.init_size)))
565
                    continue;
566
            break;
567
        }
568
        if (confframe >= start+count)
569
            panic("Cannot find configuration data for zone.");
570
    }
571
 
572
    z = zone_construct(start, count, (zone_t *)PA2KA(PFN2ADDR(confframe)), flags);
573
    zones_add_zone(z);
574
 
575
    /* If confdata in zone, mark as unavailable */
576
    if (confframe >= start && confframe < start+count)
577
        for (i=confframe; i<confframe+confcount; i++) {
578
            zone_mark_unavailable(z, i - z->base);
579
        }
580
}
581
 
582
/***************************************/
583
/* Frame functions */
584
 
585
/** Set parent of frame */
586
void frame_set_parent(pfn_t pfn, void *data, int hint)
587
{
588
    zone_t *zone = find_zone_and_lock(pfn, &hint);
589
 
590
    ASSERT(zone);
591
 
592
    zone_get_frame(zone, pfn-zone->base)->parent = data;
593
    spinlock_unlock(&zone->lock);
594
}
595
 
596
void * frame_get_parent(pfn_t pfn, int hint)
597
{
598
    zone_t *zone = find_zone_and_lock(pfn, &hint);
599
    void *res;
600
 
601
    ASSERT(zone);
602
    res = zone_get_frame(zone, pfn - zone->base)->parent;
603
 
604
    spinlock_unlock(&zone->lock);
605
    return res;
606
}
607
 
608
/** Allocate power-of-two frames of physical memory.
609
 *
610
 * @param flags Flags for host zone selection and address processing.
611
 * @param order Allocate exactly 2^order frames.
612
 * @param pzone Preferred zone
613
 *
614
 * @return Allocated frame.
615
 */
616
pfn_t frame_alloc_generic(__u8 order, int flags, int * status, int *pzone)
617
{
618
    ipl_t ipl;
619
    int freed;
620
    pfn_t v;
621
    zone_t *zone;
622
 
623
loop:
624
    ipl = interrupts_disable();
625
    /*
626
     * First, find suitable frame zone.
627
     */
628
    zone = find_free_zone_lock(order,pzone);
629
    /* If no memory, reclaim some slab memory,
630
       if it does not help, reclaim all */
631
    if (!zone && !(flags & FRAME_NO_RECLAIM)) {
632
        freed = slab_reclaim(0);
633
        if (freed)
634
            zone = find_free_zone_lock(order,pzone);
635
        if (!zone) {
636
            freed = slab_reclaim(SLAB_RECLAIM_ALL);
637
            if (freed)
638
                zone = find_free_zone_lock(order,pzone);
639
        }
640
    }
641
    if (!zone) {
642
        if (flags & FRAME_PANIC)
643
            panic("Can't allocate frame.\n");
644
 
645
        /*
646
         * TODO: Sleep until frames are available again.
647
         */
648
        interrupts_restore(ipl);
649
 
650
        if (flags & FRAME_ATOMIC) {
651
            ASSERT(status != NULL);
652
            if (status)
653
                *status = FRAME_NO_MEMORY;
654
            return NULL;
655
        }
656
 
657
        panic("Sleep not implemented.\n");
658
        goto loop;
659
    }
660
    v = zone_frame_alloc(zone,order,flags,status);
661
    v += zone->base;
662
 
663
    spinlock_unlock(&zone->lock);
664
    interrupts_restore(ipl);
665
 
666
    if (status)
667
        *status = FRAME_OK;
668
    return v;
669
}
670
 
671
/** Free a frame.
672
 *
673
 * Find respective frame structrue for supplied addr.
674
 * Decrement frame reference count.
675
 * If it drops to zero, move the frame structure to free list.
676
 *
677
 * @param frame Frame no to be freed.
678
 */
679
void frame_free(pfn_t pfn)
680
{
681
    ipl_t ipl;
682
    zone_t *zone;
683
 
684
    ipl = interrupts_disable();
685
 
686
    /*
687
     * First, find host frame zone for addr.
688
     */
689
    zone = find_zone_and_lock(pfn,NULL);
690
    ASSERT(zone);
691
 
692
    zone_frame_free(zone, pfn-zone->base);
693
 
694
    spinlock_unlock(&zone->lock);
695
    interrupts_restore(ipl);
696
}
697
 
698
 
699
 
700
/** Mark given range unavailable in frame zones */
820 jermar 701
void frame_mark_unavailable(pfn_t start, count_t count)
814 palkovsky 702
{
703
    int i;
704
    zone_t *zone;
705
    int prefzone = 0;
706
 
707
    for (i=0; i<count; i++) {
708
        zone = find_zone_and_lock(start+i,&prefzone);
709
        if (!zone) /* PFN not found */
710
            continue;
711
        zone_mark_unavailable(zone, start+i-zone->base);
712
 
713
        spinlock_unlock(&zone->lock);
714
    }
715
}
716
 
717
/** Initialize physical memory management
718
 *
719
 * Initialize physical memory managemnt.
720
 */
721
void frame_init(void)
722
{
723
    if (config.cpu_active == 1) {
724
        zones.count = 0;
725
        spinlock_initialize(&zones.lock,"zones_glob_lock");
726
    }
727
    /* Tell the architecture to create some memory */
728
    frame_arch_init();
729
    if (config.cpu_active == 1) {
730
        frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
820 jermar 731
                       SIZE2FRAMES(config.kernel_size));
814 palkovsky 732
        if (config.init_size > 0)
733
            frame_mark_unavailable(ADDR2PFN(KA2PA(config.init_addr)),
820 jermar 734
                           SIZE2FRAMES(config.init_size));
814 palkovsky 735
    }
736
}
737
 
738
 
739
 
677 bondari 740
/** Prints list of zones
741
 *
742
 */
676 bondari 743
void zone_print_list(void) {
744
    zone_t *zone = NULL;
814 palkovsky 745
    int i;
701 jermar 746
    ipl_t ipl;
747
 
748
    ipl = interrupts_disable();
814 palkovsky 749
    spinlock_lock(&zones.lock);
686 bondari 750
    printf("Base address\tFree Frames\tBusy Frames\n");
751
    printf("------------\t-----------\t-----------\n");
814 palkovsky 752
    for (i=0;i<zones.count;i++) {
753
        zone = zones.info[i];
683 bondari 754
        spinlock_lock(&zone->lock);
814 palkovsky 755
        printf("%L\t%d\t\t%d\n",PFN2ADDR(zone->base),
756
               zone->free_count, zone->busy_count);
701 jermar 757
        spinlock_unlock(&zone->lock);
676 bondari 758
    }
814 palkovsky 759
    spinlock_unlock(&zones.lock);
701 jermar 760
    interrupts_restore(ipl);
676 bondari 761
}
762
 
677 bondari 763
/** Prints zone details
764
 *
683 bondari 765
 * @param base Zone base address
677 bondari 766
 */
814 palkovsky 767
void zone_print_one(int znum) {
768
    zone_t *zone = NULL;
701 jermar 769
    ipl_t ipl;
770
 
771
    ipl = interrupts_disable();
814 palkovsky 772
    spinlock_lock(&zones.lock);
683 bondari 773
 
814 palkovsky 774
    if (znum >= zones.count || znum < 0) {
775
        printf("Zone number out of bounds.\n");
776
        spinlock_unlock(&zones.lock);
701 jermar 777
        interrupts_restore(ipl);
676 bondari 778
        return;
779
    }
780
 
814 palkovsky 781
    zone = zones.info[znum];
782
 
683 bondari 783
    spinlock_lock(&zone->lock);
784
    printf("Memory zone information\n\n");
814 palkovsky 785
    printf("Zone base address: %P\n", PFN2ADDR(zone->base));
786
    printf("Zone size: %d frames (%dK)\n", zone->count, ((zone->count) * FRAME_SIZE) >> 10);
701 jermar 787
    printf("Allocated space: %d frames (%dK)\n", zone->busy_count, (zone->busy_count * FRAME_SIZE) >> 10);
788
    printf("Available space: %d (%dK)\n", zone->free_count, (zone->free_count * FRAME_SIZE) >> 10);
683 bondari 789
 
790
    printf("\nBuddy allocator structures:\n\n");
686 bondari 791
    buddy_system_structure_print(zone->buddy_system, FRAME_SIZE);
683 bondari 792
 
793
    spinlock_unlock(&zone->lock);
814 palkovsky 794
    spinlock_unlock(&zones.lock);
701 jermar 795
    interrupts_restore(ipl);
676 bondari 796
}
797