Changeset 048dcd2 in rtems for cpukit/libblock/src/bdbuf.c


Ignore:
Timestamp:
Apr 15, 2004, 2:50:20 PM (16 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
1b4f2b30
Parents:
1f788a3
Message:

Remove stray white spaces.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libblock/src/bdbuf.c

    r1f788a3 r048dcd2  
    6060    bdbuf_pool    *pool;         /* Table of buffer pools */
    6161    int            npools;       /* Number of entries in pool table */
    62    
     62
    6363    Chain_Control  mod;          /* Modified buffers list */
    6464    rtems_id       flush_sema;   /* Buffer flush semaphore; counting
     
    9494
    9595#else
    96  
     96
    9797typedef boolean preemption_key;
    9898
     
    102102        _Thread_Executing->is_preemptible = 0;       \
    103103    } while (0)
    104    
     104
    105105#define ENABLE_PREEMPTION(key) \
    106106    do {                                             \
     
    149149        }
    150150    }
    151    
     151
    152152    return p;
    153153}
     
    439439        }
    440440    }
    441    
     441
    442442    if (p == NULL)
    443443    {
     
    485485            t = buf_prev++;
    486486            s = r;
    487            
     487
    488488            while (s->avl.left != NULL)
    489489            {
     
    492492                r->avl.cache = -1;
    493493            }
    494            
     494
    495495            s->avl.left = q->avl.left;
    496496            r->avl.left = s->avl.right;
     
    498498            s->avl.bal = q->avl.bal;
    499499            s->avl.cache = 1;
    500            
     500
    501501            *t = q = s;
    502502        }
     
    531531            break;
    532532        }
    533        
     533
    534534        if (p->avl.cache == -1)
    535535        {
     
    573573                        p->avl.right = p2->avl.left;
    574574                        p2->avl.left = p;
    575                        
     575
    576576                        if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
    577577                        if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
    578                        
     578
    579579                        p = p2;
    580580                        p2->avl.bal = 0;
     
    627627                        p->avl.left = p2->avl.right;
    628628                        p2->avl.right = p;
    629                        
     629
    630630                        if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
    631631                        if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
     
    644644        {
    645645            q = *(buf_prev - 1);
    646            
     646
    647647            if (q->avl.cache == -1)
    648648            {
     
    661661
    662662    }
    663    
     663
    664664    return 0;
    665665}
     
    684684    rtems_status_code rc;
    685685    int i;
    686    
     686
    687687    p->blksize = config->size;
    688688    p->nblks = config->num;
    689689    p->tree = NULL;
    690    
     690
    691691    Chain_Initialize_empty(&p->free);
    692692    Chain_Initialize_empty(&p->lru);
    693    
     693
    694694    /* Allocate memory for buffer descriptors */
    695695    p->bdbufs = calloc(config->num, sizeof(bdbuf_buffer));
     
    698698        return RTEMS_NO_MEMORY;
    699699    }
    700    
     700
    701701    /* Allocate memory for buffers if required */
    702702    if (config->mem_area == NULL)
     
    714714        p->mallocd_bufs = NULL;
    715715    }
    716    
     716
    717717    for (i = 0, b = p->bdbufs; i < p->nblks; i++, b++, bufs += p->blksize)
    718718    {
     
    724724        _Chain_Append(&p->free, &b->link);
    725725    }
    726    
     726
    727727    rc = rtems_semaphore_create(
    728728        rtems_build_name('B', 'U', 'F', 'G'),
     
    732732        0,
    733733        &p->bufget_sema);
    734    
     734
    735735    if (rc != RTEMS_SUCCESSFUL)
    736736    {
     
    739739        return rc;
    740740    }
    741    
     741
    742742    return RTEMS_SUCCESSFUL;
    743743}
     
    785785    if (size <= 0)
    786786        return RTEMS_INVALID_SIZE;
    787    
     787
    788788    bd_ctx.npools = size;
    789789
     
    798798
    799799    Chain_Initialize_empty(&bd_ctx.mod);
    800    
     800
    801801    /* Initialize buffer pools and roll out if something failed */
    802802    for (i = 0; i < size; i++)
     
    827827        return rc;
    828828    }
    829    
     829
    830830    /* Create and start swapout task */
    831831    rc = rtems_task_create(
     
    923923        }
    924924    }
    925    
     925
    926926    if (bd_buf == NULL)
    927927    {
     
    10181018                              WATCHDOG_NO_TIMEOUT, level);
    10191019        }
    1020        
     1020
    10211021        *ret_buf = bd_buf;
    10221022        return RTEMS_SUCCESSFUL;
     
    10601060    if (dd == NULL)
    10611061        return RTEMS_INVALID_ID;
    1062    
     1062
    10631063    if (block >= dd->size)
    10641064    {
     
    10661066        return RTEMS_INVALID_NUMBER;
    10671067    }
    1068    
     1068
    10691069    pdd = dd->phys_dev;
    10701070    block += dd->start;
     
    11791179    preemption_key key;
    11801180    ISR_Level level;
    1181    
     1181
    11821182    bdbuf_buffer *bd_buf;
    11831183    rtems_status_code rc;
     
    11901190    if (dd == NULL)
    11911191        return RTEMS_INVALID_ID;
    1192      
     1192
    11931193    if (block >= dd->size)
    11941194    {
     
    11961196        return RTEMS_INVALID_NUMBER;
    11971197    }
    1198    
     1198
    11991199    pdd = dd->phys_dev;
    12001200    block += dd->start;
     
    12221222        req.req.bufs[0].length = dd->block_size;
    12231223        req.req.bufs[0].buffer = bd_buf->buffer;
    1224        
     1224
    12251225        bdbuf_initialize_transfer_sema(bd_buf);
    12261226        result = dd->ioctl(pdd->dev, BLKIO_REQUEST, &req);
     
    12411241    }
    12421242    rtems_disk_release(dd);
    1243    
     1243
    12441244    ENABLE_PREEMPTION(key);
    12451245
    12461246    *bd = bd_buf;
    1247            
     1247
    12481248    return RTEMS_SUCCESSFUL;
    12491249}
     
    12761276    if (bd_buf->use_count <= 0)
    12771277        return RTEMS_INTERNAL_ERROR;
    1278    
     1278
    12791279    bd_pool = bd_ctx.pool + bd_buf->pool;
    12801280
     
    12851285        if (bd_buf->modified)
    12861286        {
    1287            
     1287
    12881288            /* Buffer was modified. Insert buffer to the modified buffers
    12891289             * list and initiate flushing. */
     
    13321332    if (bd_buf == NULL)
    13331333        return RTEMS_INVALID_ADDRESS;
    1334    
     1334
    13351335    DISABLE_PREEMPTION(key);
    1336    
     1336
    13371337    rc = bdbuf_release(bd_buf);
    1338    
     1338
    13391339    ENABLE_PREEMPTION(key);
    1340    
     1340
    13411341    return rc;
    13421342}
     
    13681368    if (bd_buf == NULL)
    13691369        return RTEMS_INVALID_ADDRESS;
    1370    
     1370
    13711371    DISABLE_PREEMPTION(key);
    13721372
     
    13781378    bd_buf->actual = TRUE;
    13791379    rc = bdbuf_release(bd_buf);   
    1380    
     1380
    13811381    ENABLE_PREEMPTION(key);
    1382    
     1382
    13831383    return rc;
    13841384}
     
    14111411    if (bd_buf == NULL)
    14121412        return RTEMS_INVALID_ADDRESS;
    1413    
     1413
    14141414    DISABLE_PREEMPTION(key);
    14151415
     
    14291429                          WATCHDOG_NO_TIMEOUT, level);
    14301430    }
    1431    
     1431
    14321432    ENABLE_PREEMPTION(key);
    1433    
     1433
    14341434    return rc;
    14351435}
     
    14511451    preemption_key key;
    14521452    ISR_Level level;
    1453            
     1453
    14541454    bdbuf_buffer *bd_buf;
    14551455    disk_device *dd;
    14561456    bdbuf_pool  *pool;
    1457    
     1457
    14581458    dd = rtems_disk_lookup(dev);
    14591459    if (dd == NULL)
    14601460        return RTEMS_INVALID_ID;
    1461    
     1461
    14621462    pool = bd_ctx.pool + dd->pool;
    1463        
     1463
    14641464    DISABLE_PREEMPTION(key);
    14651465    do {
     
    14981498            rtems_fatal_error_occurred(BLKDEV_FATAL_BDBUF_SWAPOUT);
    14991499        }
    1500            
     1500
    15011501        bd_buf = (bdbuf_buffer *)Chain_Get(&bd_ctx.mod);
    15021502        if (bd_buf == NULL)
     
    15251525           first time */
    15261526        result = dd->ioctl(dd->phys_dev->dev, BLKIO_REQUEST, &req);
    1527        
     1527
    15281528        rtems_disk_release(dd);
    1529        
     1529
    15301530        if (result == -1)
    15311531        {
     
    15891589    rtems_boolean found = FALSE;
    15901590    int j;
    1591    
     1591
    15921592    for (j = block_size; (j != 0) && ((j & 1) == 0); j >>= 1);
    15931593    if (j != 1)
    15941594        return RTEMS_INVALID_SIZE;
    1595    
     1595
    15961596    for (i = 0, p = bd_ctx.pool; i < bd_ctx.npools; i++, p++)
    15971597    {
     
    16041604        }
    16051605    }
    1606    
     1606
    16071607    if (found)
    16081608    {
     
    16391639    if (pool >= bd_ctx.npools)
    16401640        return RTEMS_INVALID_NUMBER;
    1641    
     1641
    16421642    if (block_size != NULL)
    16431643    {
    16441644        *block_size = bd_ctx.pool[pool].blksize;
    16451645    }
    1646    
     1646
    16471647    if (blocks != NULL)
    16481648    {
    16491649        *blocks = bd_ctx.pool[pool].nblks;
    16501650    }
    1651    
     1651
    16521652    return RTEMS_SUCCESSFUL;
    16531653}
Note: See TracChangeset for help on using the changeset viewer.