Changeset 1b20da0 in mainline for uspace/srv/fs


Ignore:
Timestamp:
2018-02-28T17:52:03Z (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:
3061bc1
Parents:
df6ded8
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:26:03)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:52:03)
Message:

style: Remove trailing whitespace on non-empty lines, in certain file types.

Command used: tools/srepl '\([^[:space:]]\)\s\+$' '\1' -- *.c *.h *.py *.sh *.s *.S *.ag

Location:
uspace/srv/fs
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/cdfs/cdfs_ops.c

    rdf6ded8 r1b20da0  
    276276static hash_table_t nodes;
    277277
    278 /* 
     278/*
    279279 * Hash table support functions.
    280280 */
    … …  
    810810        *size = BLOCK_SIZE;
    811811       
    812         return EOK; 
     812        return EOK;
    813813}
    814814
    … …  
    12061206}
    12071207
    1208 static bool rm_service_id_nodes(ht_link_t *item, void *arg) 
     1208static bool rm_service_id_nodes(ht_link_t *item, void *arg)
    12091209{
    12101210        service_id_t service_id = *(service_id_t*)arg;

  • uspace/srv/fs/exfat/exfat.c

    rdf6ded8 r1b20da0  
    3131/** @addtogroup fs
    3232 * @{
    33  */ 
     33 */
    3434
    3535/**

  • uspace/srv/fs/exfat/exfat.h

    rdf6ded8 r1b20da0  
    3030/** @addtogroup fs
    3131 * @{
    32  */ 
     32 */
    3333
    3434#ifndef EXFAT_EXFAT_H_

  • uspace/srv/fs/exfat/exfat_bitmap.c

    rdf6ded8 r1b20da0  
    4848
    4949
    50 errno_t exfat_bitmap_is_free(exfat_bs_t *bs, service_id_t service_id, 
     50errno_t exfat_bitmap_is_free(exfat_bs_t *bs, service_id_t service_id,
    5151    exfat_cluster_t clst)
    5252{
    … …  
    8989}
    9090
    91 errno_t exfat_bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id, 
     91errno_t exfat_bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id,
    9292    exfat_cluster_t clst)
    9393{
    … …  
    124124}
    125125
    126 errno_t exfat_bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id, 
     126errno_t exfat_bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id,
    127127    exfat_cluster_t clst)
    128128{
    … …  
    160160}
    161161
    162 errno_t exfat_bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id, 
     162errno_t exfat_bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id,
    163163    exfat_cluster_t firstc, exfat_cluster_t count)
    164164{
    … …  
    180180}
    181181
    182 errno_t exfat_bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id, 
     182errno_t exfat_bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id,
    183183    exfat_cluster_t firstc, exfat_cluster_t count)
    184184{
    … …  
    196196}
    197197
    198 errno_t exfat_bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id, 
     198errno_t exfat_bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id,
    199199    exfat_cluster_t *firstc, exfat_cluster_t count)
    200200{
    … …  
    217217
    218218
    219 errno_t exfat_bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
     219errno_t exfat_bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
    220220    exfat_cluster_t count)
    221221{
    222222        if (nodep->firstc == 0) {
    223                 return exfat_bitmap_alloc_clusters(bs, nodep->idx->service_id, 
     223                return exfat_bitmap_alloc_clusters(bs, nodep->idx->service_id,
    224224                    &nodep->firstc, count);
    225225        } else {
    … …  
    230230                while (exfat_bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
    231231                        if (clst - lastc == count){
    232                                 return exfat_bitmap_set_clusters(bs, nodep->idx->service_id, 
     232                                return exfat_bitmap_set_clusters(bs, nodep->idx->service_id,
    233233                                    lastc + 1, count);
    234234                        } else
    … …  
    240240
    241241
    242 errno_t exfat_bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep, 
     242errno_t exfat_bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
    243243    exfat_cluster_t count)
    244244{

  • uspace/srv/fs/exfat/exfat_dentry.c

    rdf6ded8 r1b20da0  
    2929/** @addtogroup fs
    3030 * @{
    31  */ 
     31 */
    3232
    3333/**
    … …  
    143143/**
    144144 * @}
    145  */ 
     145 */

  • uspace/srv/fs/exfat/exfat_dentry.h

    rdf6ded8 r1b20da0  
    2929/** @addtogroup fs
    3030 * @{
    31  */ 
     31 */
    3232
    3333#ifndef EXFAT_EXFAT_DENTRY_H_
    … …  
    8282
    8383typedef struct {
    84         uint8_t         count; /* Always zero */ 
     84        uint8_t         count; /* Always zero */
    8585        uint16_t        checksum;
    8686        uint16_t        flags;

  • uspace/srv/fs/exfat/exfat_directory.c

    rdf6ded8 r1b20da0  
    2929/** @addtogroup fs
    3030 * @{
    31  */ 
     31 */
    3232
    3333/**
    … …  
    6363{
    6464        exfat_directory_init(di);
    65         di->nodep = nodep;     
     65        di->nodep = nodep;
    6666        if (di->nodep->type != EXFAT_DIRECTORY)
    6767                return EINVAL;
    … …  
    7676}
    7777
    78 errno_t exfat_directory_open_parent(exfat_directory_t *di, 
     78errno_t exfat_directory_open_parent(exfat_directory_t *di,
    7979    service_id_t service_id, exfat_cluster_t firstc, bool fragmented)
    8080{
    … …  
    213213
    214214
    215 errno_t exfat_directory_read_file(exfat_directory_t *di, char *name, size_t size, 
     215errno_t exfat_directory_read_file(exfat_directory_t *di, char *name, size_t size,
    216216    exfat_file_dentry_t *df, exfat_stream_dentry_t *ds)
    217217{
    … …  
    232232        if (rc != EOK)
    233233                return rc;
    234         rc = exfat_directory_get(di, &d); 
     234        rc = exfat_directory_get(di, &d);
    235235        if (rc != EOK)
    236236                return rc;
    … …  
    246246                if (rc != EOK)
    247247                        return rc;
    248                 rc = exfat_directory_get(di, &d); 
     248                rc = exfat_directory_get(di, &d);
    249249                if (rc != EOK)
    250250                        return rc;
    … …  
    303303}
    304304
    305 errno_t exfat_directory_sync_file(exfat_directory_t *di, exfat_file_dentry_t *df, 
     305errno_t exfat_directory_sync_file(exfat_directory_t *di, exfat_file_dentry_t *df,
    306306    exfat_stream_dentry_t *ds)
    307307{
    … …  
    388388
    389389        uctable_chars = ALIGN_DOWN(uctablep->size,
    390             sizeof(uint16_t)) / sizeof(uint16_t); 
     390            sizeof(uint16_t)) / sizeof(uint16_t);
    391391        uctable = (uint16_t *) malloc(uctable_chars * sizeof(uint16_t));
    392392        rc = exfat_read_uctable(di->bs, uctablep, (uint8_t *)uctable);
    … …  
    403403        ds.stream.data_size = 0;
    404404        ds.stream.name_size = utf16_wsize(wname);
    405         ds.stream.hash = host2uint16_t_le(exfat_name_hash(wname, uctable, 
     405        ds.stream.hash = host2uint16_t_le(exfat_name_hash(wname, uctable,
    406406            uctable_chars));
    407407
    … …  
    409409        df.type = EXFAT_TYPE_FILE;
    410410        df.file.attr = 0;
    411         df.file.count = ROUND_UP(ds.stream.name_size, EXFAT_NAME_PART_LEN) / 
     411        df.file.count = ROUND_UP(ds.stream.name_size, EXFAT_NAME_PART_LEN) /
    412412            EXFAT_NAME_PART_LEN + 1;
    413413        df.file.checksum = 0;
    … …  
    553553                                }
    554554                        }
    555                 } while (exfat_directory_next(di) == EOK);     
     555                } while (exfat_directory_next(di) == EOK);
    556556        } while (exfat_directory_expand(di) == EOK);
    557557        return ENOSPC;
    … …  
    561561/**
    562562 * @}
    563  */ 
     563 */

  • uspace/srv/fs/exfat/exfat_fat.c

    rdf6ded8 r1b20da0  
    7474 */
    7575errno_t
    76 exfat_cluster_walk(exfat_bs_t *bs, service_id_t service_id, 
     76exfat_cluster_walk(exfat_bs_t *bs, service_id_t service_id,
    7777    exfat_cluster_t firstc, exfat_cluster_t *lastc, uint32_t *numc,
    7878    uint32_t max_clusters)
    … …  
    141141                         * when fortunately we have the last cluster number cached.
    142142                         */
    143                         return block_get(block, nodep->idx->service_id, DATA_FS(bs) + 
    144                         (nodep->lastc_cached_value-EXFAT_CLST_FIRST)*SPC(bs) + 
     143                        return block_get(block, nodep->idx->service_id, DATA_FS(bs) +
     144                        (nodep->lastc_cached_value-EXFAT_CLST_FIRST)*SPC(bs) +
    145145                            (bn % SPC(bs)), flags);
    146146                }
    … …  
    187187 */
    188188errno_t
    189 exfat_block_get_by_clst(block_t **block, exfat_bs_t *bs, 
     189exfat_block_get_by_clst(block_t **block, exfat_bs_t *bs,
    190190    service_id_t service_id, bool fragmented, exfat_cluster_t fcl,
    191191    exfat_cluster_t *clp, aoff64_t bn, int flags)
    … …  
    200200
    201201        if (!fragmented) {
    202                 rc = block_get(block, service_id, DATA_FS(bs) + 
     202                rc = block_get(block, service_id, DATA_FS(bs) +
    203203                    (fcl - EXFAT_CLST_FIRST)*SPC(bs) + bn, flags);
    204204        } else {
    … …  
    209209                assert(clusters == max_clusters);
    210210
    211                 rc = block_get(block, service_id, DATA_FS(bs) + 
     211                rc = block_get(block, service_id, DATA_FS(bs) +
    212212                    (c - EXFAT_CLST_FIRST) * SPC(bs) + (bn % SPC(bs)), flags);
    213213

  • uspace/srv/fs/exfat/exfat_idx.c

    rdf6ded8 r1b20da0  
    2929/** @addtogroup fs
    3030 * @{
    31  */ 
     31 */
    3232
    3333/**
    … …  
    9292
    9393        list_foreach(unused_list, link, unused_t, u) {
    94                 if (u->service_id == service_id) 
     94                if (u->service_id == service_id)
    9595                        return u;
    9696        }
    … …  
    108108 * The index structures are hashed by the service_id, parent node's first
    109109 * cluster and index within the parent directory.
    110  */ 
     110 */
    111111static hash_table_t up_hash;
    112112
    … …  
    211211        u = unused_find(service_id, true);
    212212        if (!u)
    213                 return false;   
     213                return false;
    214214
    215215        if (list_empty(&u->freed_list)) {
    216                 if (u->remaining) { 
     216                if (u->remaining) {
    217217                        /*
    218218                         * There are no freed indices, allocate one directly
    … …  
    333333
    334334        fidx = (exfat_idx_t *) malloc(sizeof(exfat_idx_t));
    335         if (!fidx) 
     335        if (!fidx)
    336336                return ENOMEM;
    337337        if (!exfat_index_alloc(service_id, &fidx->index)) {
    … …  
    470470errno_t exfat_idx_init(void)
    471471{
    472         if (!hash_table_create(&up_hash, 0, 0, &uph_ops)) 
     472        if (!hash_table_create(&up_hash, 0, 0, &uph_ops))
    473473                return ENOMEM;
    474474        if (!hash_table_create(&ui_hash, 0, 0, &uih_ops)) {
    … …  
    536536         * Remove this instance's index structure from up_hash and ui_hash.
    537537         * Process up_hash first and ui_hash second because the index structure
    538          * is actually removed in idx_remove_callback(). 
     538         * is actually removed in idx_remove_callback().
    539539         */
    540540        fibril_mutex_lock(&used_lock);
    … …  
    557557                free(f);
    558558        }
    559         free(u); 
     559        free(u);
    560560}
    561561
    562562/**
    563563 * @}
    564  */ 
     564 */

  • uspace/srv/fs/exfat/exfat_ops.c

    rdf6ded8 r1b20da0  
    139139        ds.data_size = node->size;
    140140
    141         exfat_directory_open_parent(&di, node->idx->service_id, node->idx->pfc, 
     141        exfat_directory_open_parent(&di, node->idx->service_id, node->idx->pfc,
    142142            node->idx->parent_fragmented);
    143143        rc = exfat_directory_seek(&di, node->idx->pdi);
    … …  
    269269}
    270270
    271 static errno_t exfat_node_get_new_by_pos(exfat_node_t **nodepp, 
     271static errno_t exfat_node_get_new_by_pos(exfat_node_t **nodepp,
    272272    service_id_t service_id, exfat_cluster_t pfc, unsigned pdi)
    273273{
    … …  
    320320                return rc;
    321321
    322         exfat_directory_open_parent(&di, idxp->service_id, idxp->pfc, 
     322        exfat_directory_open_parent(&di, idxp->service_id, idxp->pfc,
    323323            idxp->parent_fragmented);
    324324        rc = exfat_directory_seek(&di, idxp->pdi);
    … …  
    338338        case EXFAT_DENTRY_FILE:
    339339                nodep->type =
    340                     (uint16_t_le2host(d->file.attr) & EXFAT_ATTR_SUBDIR) ? 
     340                    (uint16_t_le2host(d->file.attr) & EXFAT_ATTR_SUBDIR) ?
    341341                    EXFAT_DIRECTORY : EXFAT_FILE;
    342342                rc = exfat_directory_next(&di);
    … …  
    708708                                nodep->firstc);
    709709                else
    710                         rc = exfat_bitmap_free_clusters(bs, nodep, 
     710                        rc = exfat_bitmap_free_clusters(bs, nodep,
    711711                            ROUND_UP(nodep->size, BPC(bs)) / BPC(bs));
    712         } 
     712        }
    713713
    714714        exfat_idx_destroy(nodep->idx);
    … …  
    10601060
    10611061        /* Initialize the root node. */
    1062         rc = exfat_node_get_new_by_pos(&rootp, service_id, EXFAT_ROOT_PAR, 
     1062        rc = exfat_node_get_new_by_pos(&rootp, service_id, EXFAT_ROOT_PAR,
    10631063            EXFAT_ROOT_POS);
    10641064        if (rc!=EOK) {
    … …  
    11101110        }
    11111111
    1112         rc = exfat_node_get_new_by_pos(&bitmapp, service_id, rootp->firstc, 
     1112        rc = exfat_node_get_new_by_pos(&bitmapp, service_id, rootp->firstc,
    11131113            di.pos);
    11141114        if (rc != EOK) {
    … …  
    11511151        }
    11521152
    1153         rc = exfat_node_get_new_by_pos(&uctablep, service_id, rootp->firstc, 
     1153        rc = exfat_node_get_new_by_pos(&uctablep, service_id, rootp->firstc,
    11541154            di.pos);
    11551155        if (rc != EOK) {

  • uspace/srv/fs/fat/fat.c

    rdf6ded8 r1b20da0  
    3131/** @addtogroup fs
    3232 * @{
    33  */ 
     33 */
    3434
    3535/**

  • uspace/srv/fs/fat/fat.h

    rdf6ded8 r1b20da0  
    3030/** @addtogroup fs
    3131 * @{
    32  */ 
     32 */
    3333
    3434#ifndef FAT_FAT_H_

  • uspace/srv/fs/fat/fat_dentry.c

    rdf6ded8 r1b20da0  
    3030/** @addtogroup fs
    3131 * @{
    32  */ 
     32 */
    3333
    3434/**
    … …  
    263263 *
    264264 * @param str  NULL-terminated (or not) string. The pointer comes from a packed
    265  *             structure and as such is expected to be unaligned. 
     265 *             structure and as such is expected to be unaligned.
    266266 * @param size Maximum number of bytes to consider.
    267267 *
    … …  
    274274
    275275        while (offset < size) {
    276                 if (str[offset] == 0 || str[offset] == FAT_LFN_PAD) 
     276                if (str[offset] == 0 || str[offset] == FAT_LFN_PAD)
    277277                        break;
    278278                offset++;
    … …  
    294294        size += fat_lfn_str_nlength(FAT_LFN_PART1(d), FAT_LFN_PART1_SIZE);
    295295        size += fat_lfn_str_nlength(FAT_LFN_PART2(d), FAT_LFN_PART2_SIZE);
    296         size += fat_lfn_str_nlength(FAT_LFN_PART3(d), FAT_LFN_PART3_SIZE);     
     296        size += fat_lfn_str_nlength(FAT_LFN_PART3(d), FAT_LFN_PART3_SIZE);
    297297       
    298298        return size;
    … …  
    429429/**
    430430 * @}
    431  */ 
     431 */

  • uspace/srv/fs/fat/fat_dentry.h

    rdf6ded8 r1b20da0  
    3030/** @addtogroup fs
    3131 * @{
    32  */ 
     32 */
    3333
    3434#ifndef FAT_FAT_DENTRY_H_

  • uspace/srv/fs/fat/fat_directory.c

    rdf6ded8 r1b20da0  
    2929/** @addtogroup fs
    3030 * @{
    31  */ 
     31 */
    3232
    3333/**
    … …  
    4949{
    5050        di->b = NULL;
    51         di->nodep = nodep;     
     51        di->nodep = nodep;
    5252        if (di->nodep->type != FAT_DIRECTORY)
    5353                return EINVAL;
    … …  
    183183                                /* We found long entry */
    184184                                long_entry_count--;
    185                                 if ((FAT_LFN_ORDER(d) == long_entry_count) && 
     185                                if ((FAT_LFN_ORDER(d) == long_entry_count) &&
    186186                                    (checksum == FAT_LFN_CHKSUM(d))) {
    187187                                        /* Right order! */
    … …  
    201201                                        long_entry = true;
    202202                                        long_entry_count = FAT_LFN_COUNT(d);
    203                                         lfn_size = (FAT_LFN_ENTRY_SIZE * 
     203                                        lfn_size = (FAT_LFN_ENTRY_SIZE *
    204204                                            (FAT_LFN_COUNT(d) - 1)) +
    205205                                            fat_lfn_size(d);
    … …  
    212212                        break;
    213213                case FAT_DENTRY_VALID:
    214                         if (long_entry && 
     214                        if (long_entry &&
    215215                            (checksum == fat_dentry_chksum(d->name))) {
    216216                                wname[lfn_size] = '\0';
    … …  
    253253        while (!flag && fat_directory_prev(di) == EOK) {
    254254                if (fat_directory_get(di, &d) == EOK &&
    255                     fat_classify_dentry(d) == FAT_DENTRY_LFN && 
     255                    fat_classify_dentry(d) == FAT_DENTRY_LFN &&
    256256                    checksum == FAT_LFN_CHKSUM(d)) {
    257257                        if (FAT_IS_LFN(d))
    … …  
    479479                                break;
    480480                        }
    481                 } while (fat_directory_next(di) == EOK);       
     481                } while (fat_directory_next(di) == EOK);
    482482        } while (fat_directory_expand(di) == EOK);
    483483
    … …  
    564564/**
    565565 * @}
    566  */ 
     566 */

  • uspace/srv/fs/fat/fat_fat.c

    rdf6ded8 r1b20da0  
    520520                        return rc;
    521521                }
    522         } else 
     522        } else
    523523                ((uint8_t *) b->data)[(offset % BPS(bs)) + 1] = byte2;
    524524
    … …  
    966966                 * set to one.
    967967                 */
    968                 if (!FAT_IS_FAT12(bs) && 
     968                if (!FAT_IS_FAT12(bs) &&
    969969                    ((e0 >> 8) != (FAT_MASK(bs) >> 8) || e1 != FAT_MASK(bs)))
    970970                        return ENOTSUP;

  • uspace/srv/fs/fat/fat_idx.c

    rdf6ded8 r1b20da0  
    2929/** @addtogroup fs
    3030 * @{
    31  */ 
     31 */
    3232
    3333/**
    … …  
    9292
    9393        list_foreach(unused_list, link, unused_t, u) {
    94                 if (u->service_id == service_id) 
     94                if (u->service_id == service_id)
    9595                        return u;
    9696        }
    … …  
    108108 * The index structures are hashed by the service_id, parent node's first
    109109 * cluster and index within the parent directory.
    110  */ 
     110 */
    111111static hash_table_t up_hash;
    112112
    … …  
    211211        u = unused_find(service_id, true);
    212212        if (!u)
    213                 return false;   
     213                return false;
    214214
    215215        if (list_empty(&u->freed_list)) {
    216                 if (u->remaining) { 
     216                if (u->remaining) {
    217217                        /*
    218218                         * There are no freed indices, allocate one directly
    … …  
    333333
    334334        fidx = (fat_idx_t *) malloc(sizeof(fat_idx_t));
    335         if (!fidx) 
     335        if (!fidx)
    336336                return ENOMEM;
    337337        if (!fat_index_alloc(service_id, &fidx->index)) {
    … …  
    469469errno_t fat_idx_init(void)
    470470{
    471         if (!hash_table_create(&up_hash, 0, 0, &uph_ops)) 
     471        if (!hash_table_create(&up_hash, 0, 0, &uph_ops))
    472472                return ENOMEM;
    473473        if (!hash_table_create(&ui_hash, 0, 0, &uih_ops)) {
    … …  
    535535         * Remove this instance's index structure from up_hash and ui_hash.
    536536         * Process up_hash first and ui_hash second because the index structure
    537          * is actually removed in idx_remove_callback(). 
     537         * is actually removed in idx_remove_callback().
    538538         */
    539539        fibril_mutex_lock(&used_lock);
    … …  
    556556                free(f);
    557557        }
    558         free(u); 
     558        free(u);
    559559}
    560560
    561561/**
    562562 * @}
    563  */ 
     563 */

  • uspace/srv/fs/fat/fat_ops.c

    rdf6ded8 r1b20da0  
    312312        d = ((fat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
    313313        if (FAT_IS_FAT32(bs)) {
    314                 nodep->firstc = uint16_t_le2host(d->firstc_lo) | 
     314                nodep->firstc = uint16_t_le2host(d->firstc_lo) |
    315315                    (uint16_t_le2host(d->firstc_hi) << 16);
    316316        } else
    … …  
    535535        if (flags & L_DIRECTORY)
    536536                (void) fat_free_clusters(bs, service_id, mcl);
    537         return rc;             
     537        return rc;
    538538}
    539539

  • uspace/srv/fs/locfs/locfs_ops.c

    rdf6ded8 r1b20da0  
    9797        .key_hash = services_key_hash,
    9898        .key_equal = services_key_equal,
    99         .equal = NULL, 
     99        .equal = NULL,
    100100        .remove_callback = services_remove_callback
    101101};

  • uspace/srv/fs/tmpfs/tmpfs_dump.c

    rdf6ded8 r1b20da0  
    11/*
    2  * Copyright (c) 2008 Jakub Jermar 
    3  * Copyright (c) 2008 Martin Decky 
     2 * Copyright (c) 2008 Jakub Jermar
     3 * Copyright (c) 2008 Martin Decky
    44 * All rights reserved.
    55 *
    … …  
    3030/** @addtogroup fs
    3131 * @{
    32  */ 
     32 */
    3333
    3434/**
    … …  
    172172        rc = block_init(dsid, TMPFS_COMM_SIZE);
    173173        if (rc != EOK)
    174                 return false; 
     174                return false;
    175175       
    176176        size_t bufpos = 0;
    … …  
    203203/**
    204204 * @}
    205  */ 
     205 */

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    rdf6ded8 r1b20da0  
    7676static errno_t tmpfs_root_get(fs_node_t **rfn, service_id_t service_id)
    7777{
    78         return tmpfs_node_get(rfn, service_id, TMPFS_SOME_ROOT); 
     78        return tmpfs_node_get(rfn, service_id, TMPFS_SOME_ROOT);
    7979}
    8080
    … …  
    138138hash_table_t nodes;
    139139
    140 /* 
    141  * Implementation of hash table interface for the nodes hash table. 
     140/*
     141 * Implementation of hash table interface for the nodes hash table.
    142142 */
    143143
    … …  
    248248
    249249static void tmpfs_instance_done(service_id_t service_id)
    250 {       
     250{
    251251        hash_table_apply(&nodes, rm_service_id_nodes, &service_id);
    252252}
    … …  
    283283                *rfn = NULL;
    284284        }
    285         return EOK;     
     285        return EOK;
    286286}
    287287
    … …  
    324324                nodep->index = tmpfs_next_index++;
    325325        nodep->service_id = service_id;
    326         if (lflag & L_DIRECTORY) 
     326        if (lflag & L_DIRECTORY)
    327327                nodep->type = TMPFS_DIRECTORY;
    328         else 
     328        else
    329329                nodep->type = TMPFS_FILE;
    330330
    … …  
    550550        size_t size;
    551551        if (!async_data_write_receive(&callid, &size)) {
    552                 async_answer_0(callid, EINVAL); 
     552                async_answer_0(callid, EINVAL);
    553553                return EINVAL;
    554554        }

  • uspace/srv/fs/udf/udf_idx.c

    rdf6ded8 r1b20da0  
    5555        service_id_t service_id;
    5656        fs_index_t index;
    57 } udf_ht_key_t; 
     57} udf_ht_key_t;
    5858
    5959static size_t udf_idx_hash(const ht_link_t *item)
    … …  
    8383        .key_equal = udf_idx_key_equal,
    8484        .equal = NULL,
    85         .remove_callback = NULL 
     85        .remove_callback = NULL
    8686};
    8787

  • uspace/srv/fs/udf/udf_volume.c

    rdf6ded8 r1b20da0  
    100100 * @return    EOK on success or an error code.
    101101 */
    102 errno_t udf_volume_recongnition(service_id_t service_id) 
     102errno_t udf_volume_recongnition(service_id_t service_id)
    103103{
    104104        aoff64_t addr = VRS_ADDR;
Note: See TracChangeset for help on using the changeset viewer.