Changeset 048dcd2 in rtems


Ignore:
Timestamp:
Apr 15, 2004, 2:50:20 PM (17 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.

Location:
cpukit/libblock
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libblock/include/rtems/bdbuf.h

    r1f788a3 r048dcd2  
    4949    dev_t       dev;     /* device number */
    5050    blkdev_bnum block;   /* block number on the device */
    51    
     51
    5252    char       *buffer;  /* Pointer to the buffer memory area */
    5353    rtems_status_code status; /* Last I/O operation completion status */
  • cpukit/libblock/include/rtems/blkdev.h

    r1f788a3 r048dcd2  
    7070    uint32_t    count;    /* Number of blocks to be exchanged */
    7171    uint32_t    bufnum;   /* Number of buffers provided */   
    72    
     72
    7373    blkdev_sg_buffer  bufs[0];/* List of scatter/gather buffers */
    7474} blkdev_request;
  • cpukit/libblock/include/rtems/diskdevs.h

    r1f788a3 r048dcd2  
    158158rtems_status_code
    159159rtems_disk_release(disk_device *dd);
    160  
     160
    161161/* rtems_disk_next --
    162162 *     Disk device enumerator. Looking for device having device number larger
  • 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}
  • cpukit/libblock/src/blkdev.c

    r1f788a3 r048dcd2  
    4040    dev_t dev;
    4141    disk_device *dd;
    42    
    43     dev = rtems_filesystem_make_dev_t(major, minor);
    44     dd = rtems_disk_lookup(dev);
    45     if (dd == NULL)
    46         return RTEMS_INVALID_NUMBER;
    47    
     42
     43    dev = rtems_filesystem_make_dev_t(major, minor);
     44    dd = rtems_disk_lookup(dev);
     45    if (dd == NULL)
     46        return RTEMS_INVALID_NUMBER;
     47
    4848    block_size_log2 = dd->block_size_log2;
    4949    block_size = dd->block_size;
    50    
     50
    5151    buf = args->buffer;
    5252    count = args->count;
    5353    args->bytes_moved = 0;
    54    
     54
    5555    block = args->offset >> block_size_log2;
    5656    blkofs = args->offset & (block_size - 1);
    57    
     57
    5858    while (count > 0)
    5959    {
     
    6161        int copy;
    6262        rtems_status_code rc;
    63        
     63
    6464        rc = rtems_bdbuf_read(dev, block, &diskbuf);
    6565        if (rc != RTEMS_SUCCESSFUL)
     
    101101    rtems_status_code rc;
    102102    disk_device *dd;
    103    
    104     dev = rtems_filesystem_make_dev_t(major, minor);
    105     dd = rtems_disk_lookup(dev);
    106     if (dd == NULL)
    107         return RTEMS_INVALID_NUMBER;
    108    
     103
     104    dev = rtems_filesystem_make_dev_t(major, minor);
     105    dd = rtems_disk_lookup(dev);
     106    if (dd == NULL)
     107        return RTEMS_INVALID_NUMBER;
     108
    109109    block_size_log2 = dd->block_size_log2;
    110110    block_size = dd->block_size;
    111    
     111
    112112    buf = args->buffer;
    113113    count = args->count;
    114114    args->bytes_moved = 0;
    115    
     115
    116116    block = args->offset >> block_size_log2;
    117117    blkofs = args->offset & (block_size - 1);
    118    
     118
    119119    while (count > 0)
    120120    {
    121121        bdbuf_buffer *diskbuf;
    122122        int copy;
    123        
     123
    124124        if ((blkofs == 0) && (count >= block_size))
    125125            rc = rtems_bdbuf_get(dev, block, &diskbuf);
     
    128128        if (rc != RTEMS_SUCCESSFUL)
    129129            return rc;
    130            
     130
    131131        copy = block_size - blkofs;
    132132        if (copy > count)
     
    134134        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
    135135        args->bytes_moved += copy;
    136        
     136
    137137        rc = rtems_bdbuf_release_modified(diskbuf);
    138138        if (rc != RTEMS_SUCCESSFUL)
    139139            return rc;
    140        
     140
    141141        count -= copy;
    142142        buf += copy;
     
    158158    dev_t dev;
    159159    disk_device *dd;
    160    
    161     dev = rtems_filesystem_make_dev_t(major, minor);
    162     dd = rtems_disk_lookup(dev);
    163     if (dd == NULL)
    164         return RTEMS_INVALID_NUMBER;
    165        
     160
     161    dev = rtems_filesystem_make_dev_t(major, minor);
     162    dd = rtems_disk_lookup(dev);
     163    if (dd == NULL)
     164        return RTEMS_INVALID_NUMBER;
     165
    166166    dd->uses++;
    167    
     167
    168168    rtems_disk_release(dd);
    169    
     169
    170170    return RTEMS_SUCCESSFUL;
    171171}
     
    183183    dev_t dev;
    184184    disk_device *dd;
    185    
    186     dev = rtems_filesystem_make_dev_t(major, minor);
    187     dd = rtems_disk_lookup(dev);
    188     if (dd == NULL)
    189         return RTEMS_INVALID_NUMBER;
    190        
     185
     186    dev = rtems_filesystem_make_dev_t(major, minor);
     187    dd = rtems_disk_lookup(dev);
     188    if (dd == NULL)
     189        return RTEMS_INVALID_NUMBER;
     190
    191191    dd->uses--;
    192    
     192
    193193    rtems_disk_release(dd);
    194    
     194
    195195    return RTEMS_SUCCESSFUL;
    196196}
     
    209209    disk_device *dd;
    210210    int rc;
    211    
    212     dev = rtems_filesystem_make_dev_t(major, minor);
    213     dd = rtems_disk_lookup(dev);
    214     if (dd == NULL)
    215         return RTEMS_INVALID_NUMBER;
    216    
     211
     212    dev = rtems_filesystem_make_dev_t(major, minor);
     213    dd = rtems_disk_lookup(dev);
     214    if (dd == NULL)
     215        return RTEMS_INVALID_NUMBER;
     216
    217217    switch (args->command)
    218218    {
     
    220220            args->ioctl_return = dd->block_size;
    221221            break;
    222        
     222
    223223        case BLKIO_GETSIZE:
    224224            args->ioctl_return = dd->size;
     
    229229            args->ioctl_return = (rc == RTEMS_SUCCESSFUL ? 0 : -1);
    230230            break;
    231            
     231
    232232        case BLKIO_REQUEST:
    233233        {
     
    238238            break;
    239239        }
    240        
     240
    241241        default:
    242242            args->ioctl_return = dd->ioctl(dd->phys_dev->dev, args->command,
     
    245245    }
    246246    rtems_disk_release(dd);
    247    
    248     return RTEMS_SUCCESSFUL;
    249 }
     247
     248    return RTEMS_SUCCESSFUL;
     249}
  • cpukit/libblock/src/diskdevs.c

    r1f788a3 r048dcd2  
    7373
    7474    rtems_filesystem_split_dev_t (dev, major, minor);
    75    
     75
    7676    if (major >= disktab_size)
    7777    {
     
    9393        disktab_size = newsize;
    9494    }
    95    
     95
    9696    if ((disktab[major].minor == NULL) ||
    9797        (minor >= disktab[major].size))
     
    101101        int i;
    102102        int s = disktab[major].size;
    103        
     103
    104104        if (s == 0)
    105105            newsize = DISKTAB_INITIAL_SIZE;
     
    108108        if (minor >= newsize)
    109109            newsize = minor + 1;
    110        
     110
    111111        p = realloc(disktab[major].minor, sizeof(disk_device *) * newsize);
    112112        if (p == NULL)
     
    118118        disktab[major].size = newsize;
    119119    }
    120    
     120
    121121    d = disktab[major].minor + minor;
    122122    if (*d == NULL)
     
    145145
    146146    rtems_filesystem_split_dev_t (dev, major, minor);
    147    
     147
    148148    if ((major >= disktab_size) || (disktab == NULL))
    149149        return NULL;
    150        
     150
    151151    dtab = disktab + major;
    152    
     152
    153153    if ((minor >= dtab->size) || (dtab->minor == NULL))
    154154        return NULL;
    155    
     155
    156156    return dtab->minor[minor];
    157157}
     
    176176    disk_device *dd;
    177177    char *n;
    178    
     178
    179179    dd = get_disk_entry(dev);
    180180    if (dd != NULL)
     
    182182        return RTEMS_RESOURCE_IN_USE;
    183183    }
    184    
     184
    185185    if (name == NULL)
    186186    {
     
    195195        strncpy(n, name, nlen);
    196196    }
    197    
     197
    198198    dd = create_disk_entry(dev);
    199199    if (dd == NULL)
     
    202202        return RTEMS_NO_MEMORY;
    203203    }
    204    
     204
    205205    dd->dev = dev;
    206206    dd->name = n;
    207    
     207
    208208    *diskdev = dd;
    209    
     209
    210210    return RTEMS_SUCCESSFUL;
    211211}
     
    248248    rtems_filesystem_split_dev_t (dev, major, minor);
    249249
    250    
     250
    251251    for (bs_log2 = 0, i = block_size; (i & 1) == 0; i >>= 1, bs_log2++);
    252252    if ((bs_log2 < 9) || (i != 1)) /* block size < 512 or not power of 2 */
    253253        return RTEMS_INVALID_NUMBER;
    254    
     254
    255255    rc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    256256    if (rc != RTEMS_SUCCESSFUL)
     
    265265        return rc;
    266266    }
    267    
     267
    268268    rc = create_disk(dev, name, &dd);
    269269    if (rc != RTEMS_SUCCESSFUL)
     
    273273        return rc;
    274274    }
    275    
     275
    276276    dd->phys_dev = dd;
    277277    dd->uses = 0;
     
    284284
    285285    rc = rtems_io_register_name(name, major, minor);
    286    
     286
    287287    diskdevs_protected = FALSE;
    288288    rtems_semaphore_release(diskdevs_mutex);
     
    338338        return RTEMS_INVALID_NUMBER;
    339339    }
    340    
     340
    341341    rc = create_disk(dev, name, &dd);
    342342    if (rc != RTEMS_SUCCESSFUL)
     
    346346        return rc;
    347347    }
    348    
     348
    349349    dd->phys_dev = pdd;
    350350    dd->uses = 0;
     
    359359    diskdevs_protected = FALSE;
    360360    rc = rtems_semaphore_release(diskdevs_mutex);
    361    
     361
    362362    return rc;
    363363}
     
    384384    rtems_device_major_number maj;
    385385    rtems_device_minor_number min;
    386    
     386
    387387    rc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    388388    if (rc != RTEMS_SUCCESSFUL)
     
    405405        }
    406406    }
    407    
     407
    408408    if (used != 0)
    409409    {
     
    432432        }
    433433    }
    434    
     434
    435435    diskdevs_protected = FALSE;
    436436    rc = rtems_semaphore_release(diskdevs_mutex);
     
    454454    disk_device *dd;
    455455    rtems_status_code rc;
    456    
     456
    457457    rtems_interrupt_disable(level);
    458458    if (diskdevs_protected)
     
    523523    if (major >= disktab_size)
    524524        return NULL;
    525    
     525
    526526    dtab = disktab + major;
    527527    while (TRUE)
     
    561561    if (disk_io_initialized)
    562562        return RTEMS_SUCCESSFUL;
    563    
     563
    564564    disktab_size = DISKTAB_INITIAL_SIZE;
    565565    disktab = calloc(disktab_size, sizeof(struct disk_device_table));
     
    572572        RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY |
    573573        RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL, 0, &diskdevs_mutex);
    574    
     574
    575575    if (rc != RTEMS_SUCCESSFUL)
    576576    {
     
    578578        return rc;
    579579    }
    580    
     580
    581581    rc = rtems_bdbuf_init(rtems_bdbuf_configuration,
    582582                          rtems_bdbuf_configuration_size);
    583    
     583
    584584    if (rc != RTEMS_SUCCESSFUL)
    585585    {
     
    588588        return rc;
    589589    }
    590    
     590
    591591    disk_io_initialized = 1;
    592592    return RTEMS_SUCCESSFUL;
     
    629629
    630630    rc = rtems_semaphore_release(diskdevs_mutex);
    631    
     631
    632632    /* XXX bdbuf should be released too! */
    633633    disk_io_initialized = 0;
  • cpukit/libblock/src/ide_part_table.c

    r1f788a3 r048dcd2  
    5252    bdbuf_buffer       *buf;
    5353    rtems_status_code   rc;
    54    
     54
    5555    if (sector == NULL)
    5656    {
     
    6363        return RTEMS_NO_MEMORY;
    6464    }
    65    
     65
    6666    rc = rtems_bdbuf_read(dev, sector_num, &buf);
    6767    if (rc != RTEMS_SUCCESSFUL)
     
    7070        return rc;
    7171    }
    72    
     72
    7373    memcpy(s->data, buf->buffer, RTEMS_IDE_SECTOR_SIZE);
    7474    s->sector_num = sector_num;
    7575
    7676    *sector = s;
    77    
     77
    7878    rtems_bdbuf_release(buf);
    79    
     79
    8080    return RTEMS_SUCCESSFUL;
    8181}
     
    166166        return RTEMS_INTERNAL_ERROR;
    167167    }
    168    
     168
    169169    *new_part_desc = NULL;
    170170
     
    234234        return RTEMS_INTERNAL_ERROR;
    235235    }
    236    
     236
    237237    dev = ext_part->disk_desc->dev;
    238238
     
    268268            return rc;
    269269        }
    270        
     270
    271271        if (new_part_desc == NULL)
    272272        {
     
    297297
    298298    free(sector);
    299    
     299
    300300    return RTEMS_SUCCESSFUL;
    301301}
     
    368368
    369369    free(sector);
    370    
     370
    371371    disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
    372372
     
    405405    if (part_desc == NULL)
    406406        return;
    407    
     407
    408408    if (is_extended(part_desc->sys_type))
    409409    {
     
    415415        }
    416416    }
    417    
     417
    418418    free(part_desc);
    419419}
     
    438438        partition_free(disk_desc->partitions[part_num]);
    439439    }
    440    
     440
    441441    free(disk_desc);
    442442}
     
    509509        return RTEMS_NO_MEMORY;
    510510    }
    511    
     511
    512512    /* get partition table */
    513513    rc = rtems_ide_part_table_get(dev_name, disk_desc);
  • cpukit/libblock/src/ramdisk.c

    r1f788a3 r048dcd2  
    5555    blkdev_sg_buffer *sg;
    5656    uint32_t   remains;
    57    
     57
    5858    from = (char *)rd->area + (req->start * rd->block_size);
    5959    remains = rd->block_size * req->count;
     
    9090    blkdev_sg_buffer *sg;
    9191    uint32_t   remains;
    92    
     92
    9393    to = (char *)rd->area + (req->start * rd->block_size);
    9494    remains = rd->block_size * req->count;
     
    135135                return -1;
    136136            }
    137            
     137
    138138            rd = ramdisk + minor;
    139            
     139
    140140            switch (r->req)
    141141            {
     
    145145                case BLKDEV_REQ_WRITE:
    146146                    return ramdisk_write(rd, r);
    147                    
     147
    148148                default:
    149149                    errno = EBADRQC;
     
    152152            break;
    153153        }
    154        
     154
    155155        default:
    156156            errno = EBADRQC;
     
    185185    if (rc != RTEMS_SUCCESSFUL)
    186186        return rc;
    187        
     187
    188188    r = ramdisk = calloc(rtems_ramdisk_configuration_size,
    189189                         sizeof(struct ramdisk));
    190    
     190
    191191    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
    192192    {
Note: See TracChangeset for help on using the changeset viewer.