Changeset a35b458 in mainline for uspace/srv/bd


Ignore:
Timestamp:
2018-03-02T20:10:49Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
uspace/srv/bd
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/file_bd/file_bd.c

    r3061bc1 ra35b458  
    157157        task_retval(0);
    158158        async_manager();
    159        
     159
    160160        /* Not reached */
    161161        return 0;
    … …  
    171171        bd_srvs_init(&bd_srvs);
    172172        bd_srvs.ops = &file_bd_ops;
    173        
     173
    174174        async_set_fallback_port_handler(file_bd_connection, NULL);
    175175        errno_t rc = loc_server_register(NAME);
    … …  
    178178                return rc;
    179179        }
    180        
     180
    181181        img = fopen(fname, "rb+");
    182182        if (img == NULL)
    183183                return EINVAL;
    184        
     184
    185185        if (fseek(img, 0, SEEK_END) != 0) {
    186186                fclose(img);
    187187                return EIO;
    188188        }
    189        
     189
    190190        off64_t img_size = ftell(img);
    191191        if (img_size < 0) {
    … …  
    193193                return EIO;
    194194        }
    195        
     195
    196196        num_blocks = img_size / block_size;
    197        
     197
    198198        fibril_mutex_initialize(&dev_lock);
    199        
     199
    200200        return EOK;
    201201}

  • uspace/srv/bd/rd/rd.c

    r3061bc1 ra35b458  
    119119                return ELIMIT;
    120120        }
    121        
     121
    122122        fibril_rwlock_read_lock(&rd_lock);
    123123        memcpy(buf, rd_addr + ba * block_size, min(block_size * cnt, size));
    124124        fibril_rwlock_read_unlock(&rd_lock);
    125        
     125
    126126        return EOK;
    127127}
    … …  
    135135                return ELIMIT;
    136136        }
    137        
     137
    138138        fibril_rwlock_write_lock(&rd_lock);
    139139        memcpy(rd_addr + ba * block_size, buf, min(block_size * cnt, size));
    140140        fibril_rwlock_write_unlock(&rd_lock);
    141        
     141
    142142        return EOK;
    143143}
    … …  
    152152                return false;
    153153        }
    154        
     154
    155155        sysarg_t addr_phys;
    156156        ret = sysinfo_get_value("rd.address.physical", &addr_phys);
    … …  
    159159                return false;
    160160        }
    161        
     161
    162162        rd_size = ALIGN_UP(size, block_size);
    163163        unsigned int flags =
    164164            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
    165        
     165
    166166        ret = physmem_map(addr_phys,
    167167            ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags, &rd_addr);
    … …  
    170170                return false;
    171171        }
    172        
     172
    173173        printf("%s: Found RAM disk at %p, %" PRIun " bytes\n", NAME,
    174174            (void *) addr_phys, size);
    175        
     175
    176176        bd_srvs_init(&bd_srvs);
    177177        bd_srvs.ops = &rd_bd_ops;
    178        
     178
    179179        async_set_fallback_port_handler(rd_client_conn, NULL);
    180180        ret = loc_server_register(NAME);
    … …  
    183183                return false;
    184184        }
    185        
     185
    186186        service_id_t service_id;
    187187        ret = loc_service_register("bd/initrd", &service_id);
    … …  
    190190                return false;
    191191        }
    192        
     192
    193193        fibril_rwlock_initialize(&rd_lock);
    194        
     194
    195195        return true;
    196196}
    … …  
    213213{
    214214        printf("%s: HelenOS RAM disk server\n", NAME);
    215        
     215
    216216        if (!rd_init())
    217217                return -1;
    218        
     218
    219219        printf("%s: Accepting connections\n", NAME);
    220220        async_manager();
    221        
     221
    222222        /* Never reached */
    223223        return 0;

  • uspace/srv/bd/sata_bd/sata_bd.c

    r3061bc1 ra35b458  
    9494        size_t count, i;
    9595        errno_t rc;
    96                
     96
    9797        /* If device is SATA, add device to the disk array. */
    9898        disk[disk_count].sess = ahci_get_sess(funh, &disk[disk_count].dev_name);
    9999        if(disk[disk_count].sess != NULL) {
    100                
     100
    101101                ahci_get_sata_device_name(disk[disk_count].sess,
    102102                    SATA_DEV_NAME_LENGTH, disk[disk_count].sata_dev_name);
    103                
     103
    104104                ahci_get_block_size(disk[disk_count].sess,
    105105                    &disk[disk_count].block_size);
    106                
     106
    107107                ahci_get_num_blocks(disk[disk_count].sess, &disk[disk_count].blocks);
    108                
     108
    109109                bd_srvs_init(&disk[disk_count].bds);
    110110                disk[disk_count].bds.ops = &sata_bd_ops;
    111111                disk[disk_count].bds.sarg = &disk[disk_count];
    112                
     112
    113113                printf("Device %s - %s , blocks: %lu, block_size: %lu\n",
    114114                    disk[disk_count].dev_name, disk[disk_count].sata_dev_name,
    … …  
    118118                ++disk_count;
    119119        }
    120        
     120
    121121        /* search children */
    122122        rc = devman_fun_get_child(funh, &devh);
    … …  
    152152        devman_handle_t root_fun;
    153153        errno_t rc;
    154        
     154
    155155        disk_count = 0;
    156156
    … …  
    160160                return EIO;
    161161        }
    162        
     162
    163163        scan_device_tree(root_fun);
    164        
     164
    165165        return EOK;
    166166}
    … …  
    248248        errno_t rc;
    249249        category_id_t disk_cat;
    250        
     250
    251251        async_set_fallback_port_handler(sata_bd_connection, NULL);
    252252        rc = loc_server_register(NAME);
    … …  
    255255                return rc;
    256256        }
    257        
     257
    258258        rc = get_sata_disks();
    259259        if (rc != EOK) {
Note: See TracChangeset for help on using the changeset viewer.