Changeset a35b458 in mainline for uspace/srv/fs/udf/udf_ops.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 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.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 ra35b458  
    7575        if (rc != EOK)
    7676                return rc;
    77        
     77
    7878        udf_node_t *node;
    7979        rc = udf_idx_get(&node, instance, index);
    … …  
    8282                if (rc != EOK)
    8383                        return rc;
    84                
     84
    8585                rc = udf_node_get_core(node);
    8686                if (rc != EOK) {
    … …  
    8989                }
    9090        }
    91        
     91
    9292        *rfn = FS_NODE(node);
    9393        return EOK;
    … …  
    100100        if (rc != EOK)
    101101                return rc;
    102        
     102
    103103        return udf_node_get(rfn, service_id,
    104104            instance->volumes[DEFAULT_VOL].root_dir);
    … …  
    110110        if (udfn)
    111111                return udfn->instance->service_id;
    112        
     112
    113113        return 0;
    114114}
    … …  
    119119        if (name == NULL)
    120120                return ENOMEM;
    121        
     121
    122122        block_t *block = NULL;
    123123        udf_file_identifier_descriptor_t *fid = NULL;
    124124        size_t pos = 0;
    125        
     125
    126126        while (udf_get_fid(&fid, &block, UDF_NODE(pfn), pos) == EOK) {
    127127                udf_long_ad_t long_ad = fid->icb;
    128                
     128
    129129                udf_to_unix_name(name, MAX_FILE_NAME_LEN,
    130130                    (char *) fid->implementation_use + FLE16(fid->lenght_iu),
    131131                    fid->lenght_file_id, &UDF_NODE(pfn)->instance->charset);
    132                
     132
    133133                if (str_casecmp(name, component) == 0) {
    134134                        errno_t rc = udf_node_get(rfn, udf_service_get(pfn),
    135135                            udf_long_ad_to_pos(UDF_NODE(pfn)->instance, &long_ad));
    136                        
     136
    137137                        if (block != NULL)
    138138                                block_put(block);
    139                        
     139
    140140                        free(name);
    141141                        return rc;
    142142                }
    143                
     143
    144144                if (block != NULL) {
    145145                        errno_t rc = block_put(block);
    … …  
    147147                                return rc;
    148148                }
    149                
     149
    150150                pos++;
    151151        }
    152        
     152
    153153        free(name);
    154154        return ENOENT;
    … …  
    165165        if (!node)
    166166                return EINVAL;
    167        
     167
    168168        fibril_mutex_lock(&node->lock);
    169169        node->ref_cnt--;
    170170        fibril_mutex_unlock(&node->lock);
    171        
     171
    172172        /* Delete node from hash table and memory */
    173173        if (!node->ref_cnt)
    174174                udf_idx_del(node);
    175        
     175
    176176        return EOK;
    177177}
    … …  
    208208        if (node)
    209209                return node->index;
    210        
     210
    211211        return 0;
    212212}
    … …  
    217217        if (node)
    218218                return node->data_size;
    219        
     219
    220220        return 0;
    221221}
    … …  
    226226        if (node)
    227227                return node->link_cnt;
    228        
     228
    229229        return 0;
    230230}
    … …  
    235235        if (node)
    236236                return node->type == NODE_DIR;
    237        
     237
    238238        return false;
    239239}
    … …  
    244244        if (node)
    245245                return node->type == NODE_FILE;
    246        
     246
    247247        return false;
    248248}
    … …  
    257257        if (NULL == instance)
    258258                return ENOENT;
    259        
     259
    260260        *size = instance->volumes[DEFAULT_VOL].logical_block_size;
    261        
     261
    262262        return EOK;
    263263}
    … …  
    266266{
    267267        *count = 0;
    268        
     268
    269269        return EOK;
    270270}
    … …  
    273273{
    274274        *count = 0;
    275        
     275
    276276        return EOK;
    277277}
    … …  
    308308{
    309309        enum cache_mode cmode;
    310        
     310
    311311        /* Check for option enabling write through. */
    312312        if (str_cmp(opts, "wtcache") == 0)
    … …  
    314314        else
    315315                cmode = CACHE_MODE_WB;
    316        
     316
    317317        udf_instance_t *instance = malloc(sizeof(udf_instance_t));
    318318        if (!instance)
    319319                return ENOMEM;
    320        
     320
    321321        instance->sector_size = 0;
    322        
     322
    323323        /* Check for block size. Will be enhanced later */
    324324        if (str_cmp(opts, "bs=512") == 0)
    … …  
    328328        else if (str_cmp(opts, "bs=2048") == 0)
    329329                instance->sector_size = 2048;
    330        
     330
    331331        /* initialize block cache */
    332332        errno_t rc = block_init(service_id, MAX_SIZE);
    333333        if (rc != EOK)
    334334                return rc;
    335        
     335
    336336        rc = fs_instance_create(service_id, instance);
    337337        if (rc != EOK) {
    … …  
    340340                return rc;
    341341        }
    342        
     342
    343343        instance->service_id = service_id;
    344344        instance->open_nodes_count = 0;
    345        
     345
    346346        /* Check Volume Recognition Sequence */
    347347        rc = udf_volume_recongnition(service_id);
    … …  
    353353                return rc;
    354354        }
    355        
     355
    356356        /* Search for Anchor Volume Descriptor */
    357357        udf_anchor_volume_descriptor_t avd;
    … …  
    364364                return rc;
    365365        }
    366        
     366
    367367        log_msg(LOG_DEFAULT, LVL_DEBUG,
    368368            "Volume: Anchor volume descriptor found. Sector size=%" PRIu32,
    … …  
    376376            PRIu32 " (sector)]", avd.reserve_extent.length,
    377377            avd.reserve_extent.location);
    378        
     378
    379379        /* Initialize the block cache */
    380380        rc = block_cache_init(service_id, instance->sector_size, 0, cmode);
    … …  
    385385                return rc;
    386386        }
    387        
     387
    388388        /* Read Volume Descriptor Sequence */
    389389        rc = udf_read_volume_descriptor_sequence(service_id, avd.main_extent);
    … …  
    396396                return rc;
    397397        }
    398        
     398
    399399        fs_node_t *rfn;
    400400        rc = udf_node_get(&rfn, service_id, instance->volumes[DEFAULT_VOL].root_dir);
    … …  
    407407                return rc;
    408408        }
    409        
     409
    410410        udf_node_t *node = UDF_NODE(rfn);
    411411        *index = instance->volumes[DEFAULT_VOL].root_dir;
    412412        *size = node->data_size;
    413        
     413
    414414        return EOK;
    415415}
    … …  
    421421        if (rc != EOK)
    422422                return rc;
    423        
     423
    424424        udf_node_t *nodep = UDF_NODE(fn);
    425425        udf_instance_t *instance = nodep->instance;
    426        
     426
    427427        /*
    428428         * We expect exactly two references on the root node.
    … …  
    434434                return EBUSY;
    435435        }
    436        
     436
    437437        /*
    438438         * Put the root node twice.
    … …  
    440440        udf_node_put(fn);
    441441        udf_node_put(fn);
    442        
     442
    443443        fs_instance_destroy(service_id);
    444444        free(instance);
    445445        block_cache_fini(service_id);
    446446        block_fini(service_id);
    447        
     447
    448448        return EOK;
    449449}
    … …  
    456456        if (rc != EOK)
    457457                return rc;
    458        
     458
    459459        fs_node_t *rfn;
    460460        rc = udf_node_get(&rfn, service_id, index);
    461461        if (rc != EOK)
    462462                return rc;
    463        
     463
    464464        udf_node_t *node = UDF_NODE(rfn);
    465        
     465
    466466        ipc_callid_t callid;
    467467        size_t len = 0;
    … …  
    471471                return EINVAL;
    472472        }
    473        
     473
    474474        if (node->type == NODE_FILE) {
    475475                if (pos >= node->data_size) {
    … …  
    479479                        return EOK;
    480480                }
    481                
     481
    482482                size_t read_len = 0;
    483483                if (node->data == NULL)
    … …  
    489489                        rc = EOK;
    490490                }
    491                
     491
    492492                *rbytes = read_len;
    493493                (void) udf_node_put(rfn);
    … …  
    498498                if (udf_get_fid(&fid, &block, node, pos) == EOK) {
    499499                        char *name = malloc(MAX_FILE_NAME_LEN + 1);
    500                        
     500
    501501                        // FIXME: Check for NULL return value
    502                        
     502
    503503                        udf_to_unix_name(name, MAX_FILE_NAME_LEN,
    504504                            (char *) fid->implementation_use + FLE16(fid->lenght_iu),
    505505                            fid->lenght_file_id, &node->instance->charset);
    506                        
     506
    507507                        async_data_read_finalize(callid, name, str_size(name) + 1);
    508508                        *rbytes = 1;
    509509                        free(name);
    510510                        udf_node_put(rfn);
    511                        
     511
    512512                        if (block != NULL)
    513513                                return block_put(block);
    514                        
     514
    515515                        return EOK;
    516516                } else {
Note: See TracChangeset for help on using the changeset viewer.