Changeset 4638401 in mainline


Ignore:
Timestamp:
2007-03-26T19:13:00Z (18 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
454f1da
Parents:
d5bd8d7
Message:

Coding style and indentation fixes.

Location:
kernel/generic/src/mm
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/mm/as.c

    rd5bd8d7 r4638401  
    412412                       
    413413                                if (overlaps(b, c * PAGE_SIZE, area->base,
    414                                     pages*PAGE_SIZE)) {
     414                                    pages * PAGE_SIZE)) {
    415415                                       
    416416                                        if (b + c * PAGE_SIZE <= start_free) {
    … …  
    554554                                    area->backend->frame_free) {
    555555                                        area->backend->frame_free(area, b +
    556                                         j * PAGE_SIZE, PTE_GET_FRAME(pte));
     556                                            j * PAGE_SIZE, PTE_GET_FRAME(pte));
    557557                                }
    558558                                page_mapping_remove(as, b + j * PAGE_SIZE);                             

  • kernel/generic/src/mm/frame.c

    rd5bd8d7 r4638401  
    7171        count_t refcount;       /**< tracking of shared frames  */
    7272        uint8_t buddy_order;    /**< buddy system block order */
    73         link_t buddy_link;      /**< link to the next free block inside one order */
     73        link_t buddy_link;      /**< link to the next free block inside one
     74                                     order */
    7475        void *parent;           /**< If allocated by slab, this points there */
    7576} frame_t;
    … …  
    7778typedef struct {
    7879        SPINLOCK_DECLARE(lock); /**< this lock protects everything below */
    79         pfn_t base;             /**< frame_no of the first frame in the frames array */
     80        pfn_t base;             /**< frame_no of the first frame in the frames
     81                                     array */
    8082        count_t count;          /**< Size of zone */
    8183
    82         frame_t *frames;        /**< array of frame_t structures in this zone */
     84        frame_t *frames;        /**< array of frame_t structures in this
     85                                     zone */
    8386        count_t free_count;     /**< number of free frame_t structures */
    8487        count_t busy_count;     /**< number of busy frame_t structures */
    … …  
    158161                /* Check for overflow */
    159162                z = zones.info[i];
    160                 if (overlaps(newzone->base,newzone->count,
    161                              z->base, z->count)) {
     163                if (overlaps(newzone->base,newzone->count, z->base,
     164                    z->count)) {
    162165                        printf("Zones overlap!\n");
    163166                        return -1;
    … …  
    167170        }
    168171        /* Move other zones up */
    169         for (j = i;j < zones.count; j++)
     172        for (j = i; j < zones.count; j++)
    170173                zones.info[j + 1] = zones.info[j];
    171174        zones.info[i] = newzone;
    … …  
    203206                spinlock_lock(&z->lock);
    204207                if (z->base <= frame && z->base + z->count > frame) {
    205                         spinlock_unlock(&zones.lock); /* Unlock the global lock */
     208                        /* Unlock the global lock */
     209                        spinlock_unlock(&zones.lock);
    206210                        if (pzone)
    207211                                *pzone = i;
    … …  
    230234 *
    231235 * @param order Size (2^order) of free space we are trying to find
    232  * @param pzone Pointer to preferred zone or NULL, on return contains zone number
     236 * @param pzone Pointer to preferred zone or NULL, on return contains zone
     237 *              number
    233238 */
    234239static zone_t * find_free_zone_and_lock(uint8_t order, unsigned int *pzone)
    … …  
    274279 */
    275280static link_t *zone_buddy_find_block(buddy_system_t *b, link_t *child,
    276                                      uint8_t order)
    277 {
    278         frame_t * frame;
    279         zone_t * zone;
     281    uint8_t order)
     282{
     283        frame_t *frame;
     284        zone_t *zone;
    280285        index_t index;
    281286       
    … …  
    294299static void zone_buddy_print_id(buddy_system_t *b, link_t *block)
    295300{
    296         frame_t * frame;
    297         zone_t * zone;
     301        frame_t *frame;
     302        zone_t *zone;
    298303        index_t index;
    299304
    … …  
    311316 * @return Buddy for given block if found
    312317 */
    313 static link_t * zone_buddy_find_buddy(buddy_system_t *b, link_t * block)
    314 {
    315         frame_t * frame;
    316         zone_t * zone;
     318static link_t *zone_buddy_find_buddy(buddy_system_t *b, link_t *block)
     319{
     320        frame_t *frame;
     321        zone_t *zone;
    317322        index_t index;
    318323        bool is_left, is_right;
    … …  
    320325        frame = list_get_instance(block, frame_t, buddy_link);
    321326        zone = (zone_t *) b->data;
    322         ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame), frame->buddy_order));
     327        ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),
     328            frame->buddy_order));
    323329       
    324330        is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
    … …  
    349355 * @return right block
    350356 */
    351 static link_t * zone_buddy_bisect(buddy_system_t *b, link_t * block) {
    352         frame_t * frame_l, * frame_r;
     357static link_t * zone_buddy_bisect(buddy_system_t *b, link_t *block) {
     358        frame_t *frame_l, *frame_r;
    353359
    354360        frame_l = list_get_instance(block, frame_t, buddy_link);
    … …  
    366372 * @return Coalesced block (actually block that represents lower address)
    367373 */
    368 static link_t * zone_buddy_coalesce(buddy_system_t *b, link_t * block_1,
    369                                     link_t * block_2)
     374static link_t *zone_buddy_coalesce(buddy_system_t *b, link_t *block_1,
     375    link_t *block_2)
    370376{
    371377        frame_t *frame1, *frame2;
    … …  
    383389 * @param order Order to set
    384390 */
    385 static void zone_buddy_set_order(buddy_system_t *b, link_t * block, uint8_t order) {
    386         frame_t * frame;
     391static void zone_buddy_set_order(buddy_system_t *b, link_t *block,
     392    uint8_t order) {
     393        frame_t *frame;
    387394        frame = list_get_instance(block, frame_t, buddy_link);
    388395        frame->buddy_order = order;
    … …  
    396403 * @return Order of block
    397404 */
    398 static uint8_t zone_buddy_get_order(buddy_system_t *b, link_t * block) {
    399         frame_t * frame;
     405static uint8_t zone_buddy_get_order(buddy_system_t *b, link_t *block) {
     406        frame_t *frame;
    400407        frame = list_get_instance(block, frame_t, buddy_link);
    401408        return frame->buddy_order;
    … …  
    421428 *
    422429 */
    423 static void zone_buddy_mark_available(buddy_system_t *b, link_t * block) {
    424         frame_t * frame;
     430static void zone_buddy_mark_available(buddy_system_t *b, link_t *block) {
     431        frame_t *frame;
    425432        frame = list_get_instance(block, frame_t, buddy_link);
    426433        frame->refcount = 0;
    … …  
    521528        if (frame->refcount)
    522529                return;
    523         link = buddy_system_alloc_block(zone->buddy_system, 
    524                                         &frame->buddy_link);
     530        link = buddy_system_alloc_block(zone->buddy_system,
     531            &frame->buddy_link);
    525532        ASSERT(link);
    526533        zone->free_count--;
    … …  
    546553        frame_t *frame;
    547554
    548         ASSERT(!overlaps(z1->base,z1->count,z2->base,z2->count));
     555        ASSERT(!overlaps(z1->base, z1->count, z2->base, z2->count));
    549556        ASSERT(z1->base < z2->base);
    550557
    551558        spinlock_initialize(&z->lock, "zone_lock");
    552559        z->base = z1->base;
    553         z->count = z2->base+z2->count - z1->base;
     560        z->count = z2->base + z2->count - z1->base;
    554561        z->flags = z1->flags & z2->flags;
    555562
    … …  
    559566        max_order = fnzb(z->count);
    560567
    561         z->buddy_system = (buddy_system_t *)&z[1];
    562         buddy_system_create(z->buddy_system, max_order, 
    563                             &zone_buddy_system_operations,
    564                             (void *) z);
    565 
    566         z->frames = (frame_t *)((uint8_t *) z->buddy_system + buddy_conf_size(max_order));
     568        z->buddy_system = (buddy_system_t *) &z[1];
     569        buddy_system_create(z->buddy_system, max_order,
     570            &zone_buddy_system_operations, (void *) z);
     571
     572        z->frames = (frame_t *)((uint8_t *) z->buddy_system +
     573            buddy_conf_size(max_order));
    567574        for (i = 0; i < z->count; i++) {
    568575                /* This marks all frames busy */
    … …  
    604611        while (zone_can_alloc(z2, 0)) {
    605612                frame_idx = zone_frame_alloc(z2, 0);
    606                 frame = &z->frames[frame_idx + (z2->base-z1->base)];
     613                frame = &z->frames[frame_idx + (z2->base - z1->base)];
    607614                frame->refcount = 0;
    608615                buddy_system_free(z->buddy_system, &frame->buddy_link);
    … …  
    669676                frame = &zone->frames[i + frame_idx];
    670677                frame->buddy_order = 0;
    671                 if (! frame->refcount)
     678                if (!frame->refcount)
    672679                        frame->refcount = 1;
    673680                ASSERT(frame->refcount == 1);
    … …  
    711718        spinlock_lock(&zone2->lock);
    712719
    713         cframes = SIZE2FRAMES(zone_conf_size(zone2->base+zone2->count-zone1->base));
     720        cframes = SIZE2FRAMES(zone_conf_size(zone2->base + zone2->count -
     721            zone1->base));
    714722        if (cframes == 1)
    715723                order = 0;
    … …  
    804812        /* Allocate frames _after_ the conframe */
    805813        /* Check sizes */
    806         z->frames = (frame_t *)((uint8_t *) z->buddy_system + buddy_conf_size(max_order));
     814        z->frames = (frame_t *)((uint8_t *) z->buddy_system +
     815            buddy_conf_size(max_order));
    807816        for (i = 0; i < count; i++) {
    808817                frame_initialize(&z->frames[i]);
    … …  
    866875                for (;confframe < start + count; confframe++) {
    867876                        addr = PFN2ADDR(confframe);
    868                         if (overlaps(addr, PFN2ADDR(confcount), KA2PA(config.base), config.kernel_size))
     877                        if (overlaps(addr, PFN2ADDR(confcount),
     878                            KA2PA(config.base), config.kernel_size))
    869879                                continue;
    870880                       
    871                         if (overlaps(addr, PFN2ADDR(confcount), KA2PA(config.stack_base), config.stack_size))
     881                        if (overlaps(addr, PFN2ADDR(confcount),
     882                            KA2PA(config.stack_base), config.stack_size))
    872883                                continue;
    873884                       
    … …  
    875886                        count_t i;
    876887                        for (i = 0; i < init.cnt; i++)
    877                                 if (overlaps(addr, PFN2ADDR(confcount), KA2PA(init.tasks[i].addr), init.tasks[i].size)) {
     888                                if (overlaps(addr, PFN2ADDR(confcount),
     889                                    KA2PA(init.tasks[i].addr),
     890                                    init.tasks[i].size)) {
    878891                                        overlap = true;
    879892                                        break;
    … …  
    916929}
    917930
    918 void * frame_get_parent(pfn_t pfn, unsigned int hint)
     931void *frame_get_parent(pfn_t pfn, unsigned int hint)
    919932{
    920933        zone_t *zone = find_zone_and_lock(pfn, &hint);
    … …  
    10741087        frame_arch_init();
    10751088        if (config.cpu_active == 1) {
    1076                 frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)), SIZE2FRAMES(config.kernel_size));
    1077                 frame_mark_unavailable(ADDR2PFN(KA2PA(config.stack_base)), SIZE2FRAMES(config.stack_size));
     1089                frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
     1090                    SIZE2FRAMES(config.kernel_size));
     1091                frame_mark_unavailable(ADDR2PFN(KA2PA(config.stack_base)),
     1092                    SIZE2FRAMES(config.stack_size));
    10781093               
    10791094                count_t i;
    1080                 for (i = 0; i < init.cnt; i++)
    1081                         frame_mark_unavailable(ADDR2PFN(KA2PA(init.tasks[i].addr)), SIZE2FRAMES(init.tasks[i].size));
     1095                for (i = 0; i < init.cnt; i++) {
     1096                        pfn_t pfn = ADDR2PFN(KA2PA(init.tasks[i].addr));
     1097                        frame_mark_unavailable(pfn,
     1098                            SIZE2FRAMES(init.tasks[i].size));
     1099                }
    10821100
    10831101                if (ballocs.size)
    1084                         frame_mark_unavailable(ADDR2PFN(KA2PA(ballocs.base)), SIZE2FRAMES(ballocs.size));
     1102                        frame_mark_unavailable(ADDR2PFN(KA2PA(ballocs.base)),
     1103                            SIZE2FRAMES(ballocs.size));
    10851104
    10861105                /* Black list first frame, as allocating NULL would
    … …  
    11071126                zone = zones.info[i];
    11081127                spinlock_lock(&zone->lock);
    1109                 printf("%-2d %12p %12zd %12zd\n", i, PFN2ADDR(zone->base), zone->free_count, zone->busy_count);
     1128                printf("%-2d %12p %12zd %12zd\n", i, PFN2ADDR(zone->base),
     1129                    zone->free_count, zone->busy_count);
    11101130                spinlock_unlock(&zone->lock);
    11111131        }
    … …  
    11391159        spinlock_lock(&zone->lock);
    11401160        printf("Memory zone information\n");
    1141         printf("Zone base address: %#.*p\n", sizeof(uintptr_t) * 2, PFN2ADDR(zone->base));
    1142         printf("Zone size: %zd frames (%zdK)\n", zone->count, ((zone->count) * FRAME_SIZE) >> 10);
    1143         printf("Allocated space: %zd frames (%zdK)\n", zone->busy_count, (zone->busy_count * FRAME_SIZE) >> 10);
    1144         printf("Available space: %zd frames (%zdK)\n", zone->free_count, (zone->free_count * FRAME_SIZE) >> 10);
     1161        printf("Zone base address: %#.*p\n", sizeof(uintptr_t) * 2,
     1162            PFN2ADDR(zone->base));
     1163        printf("Zone size: %zd frames (%zdK)\n", zone->count,
     1164            ((zone->count) * FRAME_SIZE) >> 10);
     1165        printf("Allocated space: %zd frames (%zdK)\n", zone->busy_count,
     1166            (zone->busy_count * FRAME_SIZE) >> 10);
     1167        printf("Available space: %zd frames (%zdK)\n", zone->free_count,
     1168            (zone->free_count * FRAME_SIZE) >> 10);
    11451169        buddy_system_structure_print(zone->buddy_system, FRAME_SIZE);
    11461170       
    … …  
    11531177/** @}
    11541178 */
     1179

  • kernel/generic/src/mm/tlb.c

    rd5bd8d7 r4638401  
    7979 * @param count Number of pages, if required by type.
    8080 */
    81 void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid, uintptr_t page, count_t count)
     81void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid,
     82    uintptr_t page, count_t count)
    8283{
    8384        int i;
    … …  
    108109                         * Enqueue the message.
    109110                         */
    110                         cpu->tlb_messages[cpu->tlb_messages_count].type = type;
    111                         cpu->tlb_messages[cpu->tlb_messages_count].asid = asid;
    112                         cpu->tlb_messages[cpu->tlb_messages_count].page = page;
    113                         cpu->tlb_messages[cpu->tlb_messages_count].count = count;
    114                         cpu->tlb_messages_count++;
     111                        index_t idx = cpu->tlb_messages_count++;
     112                        cpu->tlb_messages[idx].type = type;
     113                        cpu->tlb_messages[idx].asid = asid;
     114                        cpu->tlb_messages[idx].page = page;
     115                        cpu->tlb_messages[idx].count = count;
    115116                }
    116117                spinlock_unlock(&cpu->lock);
Note: See TracChangeset for help on using the changeset viewer.