Changeset a35b458 in mainline for uspace/srv/fs/udf


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/fs/udf
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 ra35b458  
    6363        log_init(NAME);
    6464        log_msg(LOG_DEFAULT, LVL_NOTE, "HelenOS UDF 1.02 file system server");
    65        
     65
    6666        if (argc == 3) {
    6767                if (!str_cmp(argv[1], "--instance"))
    … …  
    7272                }
    7373        }
    74        
     74
    7575        async_sess_t *vfs_sess =
    7676            service_connect_blocking(SERVICE_VFS, INTERFACE_VFS_DRIVER, 0);
    … …  
    7979                return 2;
    8080        }
    81        
     81
    8282        errno_t rc = fs_register(vfs_sess, &udf_vfs_info, &udf_ops,
    8383            &udf_libfs_ops);
    8484        if (rc != EOK)
    8585                goto err;
    86        
     86
    8787        rc = udf_idx_init();
    8888        if (rc != EOK)
    8989                goto err;
    90        
     90
    9191        log_msg(LOG_DEFAULT, LVL_NOTE, "Accepting connections");
    9292        task_retval(0);
    9393        async_manager();
    94        
     94
    9595        /* Not reached */
    9696        return 0;
    97        
     97
    9898err:
    9999        log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to register file system: %s", str_error(rc));

  • uspace/srv/fs/udf/udf.h

    r3061bc1 ra35b458  
    8585        size_t open_nodes_count;
    8686        udf_charspec_t charset;
    87        
     87
    8888        uint32_t sector_size;
    8989        udf_lvolume_t *volumes;
    … …  
    105105        fs_node_t *fs_node;
    106106        fibril_mutex_t lock;
    107        
     107
    108108        fs_index_t index;  /* FID logical block */
    109109        ht_link_t link;
    110110        size_t ref_cnt;
    111111        size_t link_cnt;
    112        
     112
    113113        uint8_t type;  /* 1 - file, 0 - directory */
    114114        uint64_t data_size;

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

    r3061bc1 ra35b458  
    7979{
    8080        uint16_t crc = 0;
    81        
     81
    8282        while (len-- > 0) {
    8383                /*
    … …  
    8888                crc = crc_table[(crc >> 8 ^ (*buf++ & 0xff)) & 0xff] ^ (crc << 8);
    8989        }
    90        
     90
    9191        return crc;
    9292}
    … …  
    9898{
    9999        uint8_t result = 0;
    100        
     100
    101101        for (size_t i = 0; i < UDF_TAG_SIZE; i++) {
    102102                if (i == 4)
    103103                        continue;
    104                
     104
    105105                result = (result + tag[i]) % 256;
    106106        }
    107        
     107
    108108        return result;
    109109}

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

    r3061bc1 ra35b458  
    6565        if (rc != EOK)
    6666                return rc;
    67        
     67
    6868        udf_ext_ad_t *exd = (udf_ext_ad_t *) block->data;
    6969        uint32_t start = node->instance->partitions[
    7070            FLE16(exd->extent_location.partition_num)].start +
    7171            FLE32(exd->extent_location.lblock_num);
    72        
     72
    7373        log_msg(LOG_DEFAULT, LVL_DEBUG,
    7474            "Extended allocator: start=%d, block_num=%d, len=%d", start,
    7575            FLE32(exd->extent_location.lblock_num), FLE32(exd->info_length));
    76        
     76
    7777        uint32_t len = FLE32(exd->info_length);
    7878        block_put(block);
    79        
     79
    8080        return udf_read_allocation_sequence(node, NULL, icb_flag, start, len);
    8181}
    … …  
    9797{
    9898        node->alloc_size = 0;
    99        
     99
    100100        switch (icb_flag) {
    101101        case UDF_SHORT_AD:
    102102                log_msg(LOG_DEFAULT, LVL_DEBUG,
    103103                    "ICB: sequence of allocation descriptors - icbflag = short_ad_t");
    104                
     104
    105105                /*
    106106                 * Identify number of current partition. Virtual partition
    … …  
    110110                size_t pd_num = (size_t) -1;
    111111                size_t min_start = 0;
    112                
     112
    113113                for (size_t i = 0; i < node->instance->partition_cnt; i++) {
    114114                        if ((node->index >= node->instance->partitions[i].start) &&
    … …  
    121121                        }
    122122                }
    123                
     123
    124124                if (pd_num == (size_t) -1)
    125125                        return ENOENT;
    126                
     126
    127127                /*
    128128                 * According to doc, in this we should stop our loop if pass
    … …  
    133133                 * which we check inside of loop.
    134134                 */
    135                
     135
    136136                while (true) {
    137137                        udf_short_ad_t *short_d =
    138138                            (udf_short_ad_t *) (af + start_alloc +
    139139                            node->alloc_size * sizeof(udf_short_ad_t));
    140                        
     140
    141141                        if (FLE32(short_d->length) == 0)
    142142                                break;
    143                        
     143
    144144                        /*
    145145                         * ECMA 167 4/12 - next sequence of allocation descriptors
    … …  
    152152                                break;
    153153                        }
    154                        
     154
    155155                        node->allocators = realloc(node->allocators,
    156156                            (node->alloc_size + 1) * sizeof(udf_allocator_t));
    … …  
    161161                        node->alloc_size++;
    162162                }
    163                
     163
    164164                node->allocators = realloc(node->allocators,
    165165                    node->alloc_size * sizeof(udf_allocator_t));
    166166                break;
    167                
     167
    168168        case UDF_LONG_AD:
    169169                log_msg(LOG_DEFAULT, LVL_DEBUG,
    170170                    "ICB: sequence of allocation descriptors - icbflag = long_ad_t");
    171                
     171
    172172                while (true) {
    173173                        udf_long_ad_t *long_d =
    174174                            (udf_long_ad_t *) (af + start_alloc +
    175175                            node->alloc_size * sizeof(udf_long_ad_t));
    176                        
     176
    177177                        if (FLE32(long_d->length) == 0)
    178178                                break;
    179                        
     179
    180180                        uint32_t pos_long_ad = udf_long_ad_to_pos(node->instance, long_d);
    181                        
     181
    182182                        /*
    183183                         * ECMA 167 4/12 - next sequence of allocation descriptors
    … …  
    188188                                break;
    189189                        }
    190                        
     190
    191191                        node->allocators = realloc(node->allocators,
    192192                            (node->alloc_size + 1) * sizeof(udf_allocator_t));
    … …  
    194194                            EXT_LENGTH(FLE32(long_d->length));
    195195                        node->allocators[node->alloc_size].position = pos_long_ad;
    196                        
     196
    197197                        node->alloc_size++;
    198198                }
    199                
     199
    200200                node->allocators = realloc(node->allocators,
    201201                    node->alloc_size * sizeof(udf_allocator_t));
    202202                break;
    203                
     203
    204204        case UDF_EXTENDED_AD:
    205205                log_msg(LOG_DEFAULT, LVL_DEBUG,
    206206                    "ICB: sequence of allocation descriptors - icbflag = extended_ad_t");
    207207                break;
    208                
     208
    209209        case UDF_DATA_AD:
    210210                log_msg(LOG_DEFAULT, LVL_DEBUG,
    211211                    "ICB: sequence of allocation descriptors - icbflag = 3, node contains data itself");
    212                
     212
    213213                node->data = malloc(node->data_size);
    214214                if (!node->data)
    215215                        return ENOMEM;
    216                
     216
    217217                memcpy(node->data, (af + start_alloc), node->data_size);
    218218                node->alloc_size = 0;
    219219                break;
    220220        }
    221        
     221
    222222        return EOK;
    223223}
    … …  
    237237        while (true) {
    238238                fs_index_t pos = node->index;
    239                
     239
    240240                block_t *block = NULL;
    241241                errno_t rc = block_get(&block, node->instance->service_id, pos,
    … …  
    243243                if (rc != EOK)
    244244                        return rc;
    245                
     245
    246246                udf_descriptor_tag_t *data = (udf_descriptor_tag_t *) block->data;
    247247                if (data->checksum != udf_tag_checksum((uint8_t *) data)) {
    … …  
    249249                        return EINVAL;
    250250                }
    251                
     251
    252252                /* One sector size descriptors */
    253253                switch (FLE16(data->id)) {
    254254                case UDF_FILE_ENTRY:
    255255                        log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: File entry descriptor found");
    256                        
     256
    257257                        udf_file_entry_descriptor_t *file =
    258258                            (udf_file_entry_descriptor_t *) block->data;
    … …  
    260260                        node->data_size = FLE64(file->info_lenght);
    261261                        node->type = (file->icbtag.file_type == UDF_ICBTYPE_DIR) ? NODE_DIR : NODE_FILE;
    262                        
     262
    263263                        rc = udf_read_allocation_sequence(node, (uint8_t *) file, icb_flag,
    264264                            FLE32(file->ea_lenght) + UDF_FE_OFFSET, FLE32(file->ad_lenght));
    265265                        block_put(block);
    266266                        return rc;
    267                        
     267
    268268                case UDF_EFILE_ENTRY:
    269269                        log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: Extended file entry descriptor found");
    270                        
     270
    271271                        udf_extended_file_entry_descriptor_t *efile =
    272272                            (udf_extended_file_entry_descriptor_t *) block->data;
    … …  
    274274                        node->data_size = FLE64(efile->info_lenght);
    275275                        node->type = (efile->icbtag.file_type == UDF_ICBTYPE_DIR) ? NODE_DIR : NODE_FILE;
    276                        
     276
    277277                        rc = udf_read_allocation_sequence(node, (uint8_t *) efile, icb_flag,
    278278                            FLE32(efile->ea_lenght) + UDF_EFE_OFFSET, FLE32(efile->ad_lenght));
    279279                        block_put(block);
    280280                        return rc;
    281                        
     281
    282282                case UDF_ICB_TERMINAL:
    283283                        log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: Terminal entry descriptor found");
    … …  
    285285                        return EOK;
    286286                }
    287                
     287
    288288                pos++;
    289                
     289
    290290                rc = block_put(block);
    291291                if (rc != EOK)
    292292                        return rc;
    293293        }
    294        
     294
    295295        return EOK;
    296296}
    … …  
    323323        size_t fid_sum = 0;
    324324        size_t n = 0;
    325        
     325
    326326        while (node->data_size - fid_sum >= MIN_FID_LEN) {
    327327                udf_descriptor_tag_t *desc =
    … …  
    333333                                return ENOENT;
    334334                }
    335                
     335
    336336                *fid = (udf_file_identifier_descriptor_t *)
    337337                    (node->data + fid_sum);
    338                
     338
    339339                /* According to ECMA 167 4/14.4.9 */
    340340                size_t padding = 4 * (((*fid)->lenght_file_id +
    … …  
    343343                size_t size_fid = (*fid)->lenght_file_id +
    344344                    FLE16((*fid)->lenght_iu) + padding + 38;
    345                
     345
    346346                fid_sum += size_fid;
    347                
     347
    348348                /* aAcording to ECMA 167 4/8.6 */
    349349                if (((*fid)->lenght_file_id != 0) &&
    350350                    (((*fid)->file_characteristics & 4) == 0)) {
    351351                        n++;
    352                        
     352
    353353                        if (n == pos + 1)
    354354                                return EOK;
    355355                }
    356356        }
    357        
     357
    358358        return ENOENT;
    359359}
    … …  
    374374        if (node->data == NULL)
    375375                return udf_get_fid_in_allocator(fid, block, node, pos);
    376        
     376
    377377        return udf_get_fid_in_data(fid, node, pos);
    378378}
    … …  
    392392{
    393393        void *buf = malloc(node->instance->sector_size);
    394        
     394
    395395        // FIXME: Check for NULL return value
    396        
     396
    397397        size_t j = 0;
    398398        size_t n = 0;
    399399        size_t len = 0;
    400        
     400
    401401        while (j < node->alloc_size) {
    402402                size_t i = 0;
    … …  
    408408                                return rc;
    409409                        }
    410                        
     410
    411411                        /*
    412412                         * Last item in allocator is a part of sector. We take
    … …  
    422422                                break;
    423423                        }
    424                        
     424
    425425                        rc = udf_get_fid_in_sector(fid, block, node, pos, &n, &buf, &len);
    426426                        if (rc == EOK) {
    … …  
    428428                                return EOK;
    429429                        }
    430                        
     430
    431431                        if (rc == EINVAL) {
    432432                                // FIXME: Memory leak
    433433                                return ENOENT;
    434434                        }
    435                        
     435
    436436                        if (rc == ENOENT) {
    437437                                if (block) {
    438438                                        rc = block_put(*block);
    439439                                        *block = NULL;
    440                                        
     440
    441441                                        if (rc != EOK)
    442442                                                return rc;
    443443                                }
    444444                        }
    445                        
     445
    446446                        i++;
    447447                }
    448                
     448
    449449                j++;
    450450        }
    451        
     451
    452452        if (buf)
    453453                free(buf);
    454        
     454
    455455        return ENOENT;
    456456}
    … …  
    474474{
    475475        void *fidbuf = malloc(node->instance->sector_size);
    476        
     476
    477477        // FIXME: Check for NULL return value
    478        
     478
    479479        bool buf_flag;
    480        
     480
    481481        if (*len > 0) {
    482482                memcpy(fidbuf, *buf, *len);
    … …  
    484484        } else
    485485                buf_flag = false;
    486        
     486
    487487        size_t fid_sum = 0;
    488488        while (node->instance->sector_size - fid_sum > 0) {
    489489                if (node->instance->sector_size - fid_sum >= MIN_FID_LEN) {
    490490                        void *fid_data;
    491                        
     491
    492492                        if (buf_flag) {
    493493                                memcpy((fidbuf + *len), (*block)->data,
    … …  
    496496                        } else
    497497                                fid_data = (*block)->data + fid_sum;
    498                        
     498
    499499                        udf_descriptor_tag_t *desc =
    500500                            (udf_descriptor_tag_t *) fid_data;
    501                        
     501
    502502                        if (desc->checksum != udf_tag_checksum((uint8_t *) desc)) {
    503503                                if (fidbuf)
    504504                                        free(fidbuf);
    505                                
     505
    506506                                if (*buf) {
    507507                                        free(*buf);
    … …  
    509509                                        *len = 0;
    510510                                }
    511                                
     511
    512512                                return EINVAL;
    513513                        }
    514                        
     514
    515515                        *fid = (udf_file_identifier_descriptor_t *) fid_data;
    516                        
     516
    517517                        /* According to ECMA 167 4/14.4.9 */
    518518                        size_t padding = 4 * (((*fid)->lenght_file_id +
    … …  
    525525                        else
    526526                                fid_sum += size_fid;
    527                        
     527
    528528                        /* According to ECMA 167 4/8.6 */
    529529                        if (((*fid)->lenght_file_id != 0) &&
    … …  
    533533                                        if (fidbuf)
    534534                                                free(fidbuf);
    535                                        
     535
    536536                                        return EOK;
    537537                                }
    538538                        }
    539                        
     539
    540540                        if (fidbuf) {
    541541                                buf_flag = false;
    … …  
    543543                                fidbuf = NULL;
    544544                        }
    545                        
     545
    546546                        if (*buf) {
    547547                                free(*buf);
    … …  
    552552                        if (*buf)
    553553                                free(*buf);
    554                        
     554
    555555                        *len = node->instance->sector_size - fid_sum;
    556556                        *buf = malloc(*len);
    557557                        buf_flag = false;
    558558                        memcpy(*buf, ((*block)->data + fid_sum), *len);
    559                        
     559
    560560                        return ENOENT;
    561561                }
    562562        }
    563        
     563
    564564        return ENOENT;
    565565}
    … …  
    581581        size_t i = 0;
    582582        size_t l = 0;
    583        
     583
    584584        while (i < node->alloc_size) {
    585585                if (pos >= l + node->allocators[i].length) {
    … …  
    589589                        break;
    590590        }
    591        
     591
    592592        size_t sector_cnt = ALL_UP(l, node->instance->sector_size);
    593593        size_t sector_num = pos / node->instance->sector_size;
    594        
     594
    595595        block_t *block = NULL;
    596596        errno_t rc = block_get(&block, node->instance->service_id,
    … …  
    601601                return rc;
    602602        }
    603        
     603
    604604        size_t sector_pos = pos % node->instance->sector_size;
    605        
     605
    606606        if (sector_pos + len < node->instance->sector_size)
    607607                *read_len = len;
    608608        else
    609609                *read_len = node->instance->sector_size - sector_pos;
    610        
     610
    611611        if (ALL_UP(node->allocators[i].length, node->instance->sector_size) ==
    612612            sector_num - sector_cnt + 1) {
    … …  
    618618                        *read_len = len;
    619619        }
    620        
     620
    621621        async_data_read_finalize(callid, block->data + sector_pos, *read_len);
    622622        return block_put(block);

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

    r3061bc1 ra35b458  
    9595        if (!hash_table_create(&udf_idx, 0, 0, &udf_idx_ops))
    9696                return ENOMEM;
    97        
     97
    9898        return EOK;
    9999}
    … …  
    127127                .index = index
    128128        };
    129        
     129
    130130        ht_link_t *already_open = hash_table_find(&udf_idx, &key);
    131131        if (already_open) {
    … …  
    133133                    udf_node_t, link);
    134134                node->ref_cnt++;
    135                
     135
    136136                *udfn = node;
    137                
     137
    138138                fibril_mutex_unlock(&udf_idx_lock);
    139139                return EOK;
    140140        }
    141        
     141
    142142        fibril_mutex_unlock(&udf_idx_lock);
    143143        return ENOENT;
    … …  
    156156{
    157157        fibril_mutex_lock(&udf_idx_lock);
    158        
     158
    159159        udf_node_t *udf_node = malloc(sizeof(udf_node_t));
    160160        if (udf_node == NULL) {
    … …  
    162162                return ENOMEM;
    163163        }
    164        
     164
    165165        fs_node_t *fs_node = malloc(sizeof(fs_node_t));
    166166        if (fs_node == NULL) {
    … …  
    169169                return ENOMEM;
    170170        }
    171        
     171
    172172        fs_node_initialize(fs_node);
    173        
     173
    174174        udf_node->index = index;
    175175        udf_node->instance = instance;
    … …  
    179179        udf_node->data = NULL;
    180180        udf_node->allocators = NULL;
    181        
     181
    182182        fibril_mutex_initialize(&udf_node->lock);
    183183        fs_node->data = udf_node;
    184        
     184
    185185        hash_table_insert(&udf_idx, &udf_node->link);
    186186        instance->open_nodes_count++;
    187        
     187
    188188        *udfn = udf_node;
    189        
     189
    190190        fibril_mutex_unlock(&udf_idx_lock);
    191191        return EOK;
    … …  
    202202{
    203203        assert(node->ref_cnt == 0);
    204        
     204
    205205        fibril_mutex_lock(&udf_idx_lock);
    206        
     206
    207207        hash_table_remove_item(&udf_idx, &node->link);
    208        
     208
    209209        assert(node->instance->open_nodes_count > 0);
    210210        node->instance->open_nodes_count--;
    211        
     211
    212212        free(node->fs_node);
    213213        free(node);
    214        
     214
    215215        fibril_mutex_unlock(&udf_idx_lock);
    216216        return EOK;

  • 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 {

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

    r3061bc1 ra35b458  
    5959        if ((ch == 0x0000) || (ch == 0x002F))
    6060                return false;
    61        
     61
    6262        return true;
    6363}
    … …  
    8585        /* Use udf_compressed to store current byte being read. */
    8686        uint8_t comp_id = udf_compressed[0];
    87        
     87
    8888        /* First check for valid compID. */
    8989        if ((comp_id != 8) && (comp_id != 16))
    9090                return 0;
    91        
     91
    9292        size_t unicode_idx = 0;
    9393        size_t byte_idx = 1;
    94        
     94
    9595        /* Loop through all the bytes. */
    9696        while ((byte_idx < number_of_bytes) && (unicode_idx < unicode_max_len)) {
    … …  
    103103                } else
    104104                        unicode[unicode_idx] = 0;
    105                
     105
    106106                if (byte_idx < number_of_bytes) {
    107107                        /* Then the next byte to the low bits. */
    108108                        unicode[unicode_idx] |= udf_compressed[byte_idx++];
    109109                }
    110                
     110
    111111                unicode_idx++;
    112112        }
    113        
     113
    114114        return unicode_idx;
    115115}
    … …  
    136136        size_t new_idx = 0;
    137137        size_t new_ext_idx = 0;
    138        
     138
    139139        for (size_t idx = 0; idx < udf_len; idx++) {
    140140                uint16_t current = udf_name[idx];
    141                
     141
    142142                if ((!legal_check(current)) || (!ascii_check(current))) {
    143143                        needs_crc = true;
    144                        
     144
    145145                        /*
    146146                         * Replace Illegal and non-displayable chars with
    … …  
    148148                         */
    149149                        current = ILLEGAL_CHAR_MARK;
    150                        
     150
    151151                        /*
    152152                         * Skip any other illegal or non-displayable
    … …  
    158158                                idx++;
    159159                }
    160                
     160
    161161                /* Record position of extension, if one is found. */
    162162                if ((current == PERIOD) && ((udf_len - idx - 1) <= EXT_SIZE)) {
    … …  
    170170                        }
    171171                }
    172                
     172
    173173                if (new_idx < MAXLEN)
    174174                        new_name[new_idx++] = current;
    … …  
    176176                        needs_crc = true;
    177177        }
    178        
     178
    179179        if (needs_crc) {
    180180                uint16_t ext[EXT_SIZE];
    181181                size_t local_ext_idx = 0;
    182                
     182
    183183                if (has_ext) {
    184184                        size_t max_filename_len;
    185                        
     185
    186186                        /* Translate extension, and store it in ext. */
    187187                        for (size_t idx = 0; (idx < EXT_SIZE) &&
    188188                            (ext_idx + idx + 1 < udf_len); idx++) {
    189189                                uint16_t current = udf_name[ext_idx + idx + 1];
    190                                
     190
    191191                                if ((!legal_check(current)) || (!ascii_check(current))) {
    192192                                        needs_crc = true;
    193                                        
     193
    194194                                        /*
    195195                                         * Replace Illegal and non-displayable
    … …  
    197197                                         */
    198198                                        current = ILLEGAL_CHAR_MARK;
    199                                        
     199
    200200                                        /*
    201201                                         * Skip any other illegal or
    … …  
    207207                                                idx++;
    208208                                }
    209                                
     209
    210210                                ext[local_ext_idx++] = current;
    211211                        }
    212                        
     212
    213213                        /*
    214214                         * Truncate filename to leave room for extension and
    … …  
    224224                        new_idx = MAXLEN - 5;
    225225                }
    226                
     226
    227227                /* Add mark for CRC. */
    228228                new_name[new_idx++] = CRC_MARK;
    229                
     229
    230230                /* Calculate CRC from original filename. */
    231231                uint16_t value_crc = udf_unicode_cksum(udf_name, udf_len);
    232                
     232
    233233                /* Convert 16-bits of CRC to hex characters. */
    234234                const char hex_char[] = "0123456789ABCDEF";
    235                
     235
    236236                new_name[new_idx++] = hex_char[(value_crc & 0xf000) >> 12];
    237237                new_name[new_idx++] = hex_char[(value_crc & 0x0f00) >> 8];
    238238                new_name[new_idx++] = hex_char[(value_crc & 0x00f0) >> 4];
    239239                new_name[new_idx++] = hex_char[(value_crc & 0x000f)];
    240                
     240
    241241                /* Place a translated extension at end, if found. */
    242242                if (has_ext) {
    243243                        new_name[new_idx++] = PERIOD;
    244                        
     244
    245245                        for (size_t idx = 0; idx < local_ext_idx; idx++)
    246246                                new_name[new_idx++] = ext[idx];
    247247                }
    248248        }
    249        
     249
    250250        return new_idx;
    251251}
    … …  
    265265        const char *osta_id = "OSTA Compressed Unicode";
    266266        size_t ucode_chars, nice_uchars;
    267        
     267
    268268        uint16_t *raw_name = malloc(MAX_BUF * sizeof(uint16_t));
    269269        uint16_t *unix_name = malloc(MAX_BUF * sizeof(uint16_t));
    270        
     270
    271271        // FIXME: Check for malloc returning NULL
    272        
     272
    273273        bool is_osta_typ0 = (chsp->type == 0) &&
    274274            (str_cmp((char *) chsp->info, osta_id) == 0);
    275        
     275
    276276        if (is_osta_typ0) {
    277277                *raw_name = 0;
    278278                *unix_name = 0;
    279                
     279
    280280                ucode_chars =
    281281                    udf_uncompress_unicode(len, (uint8_t *) id, raw_name, MAX_BUF);
    … …  
    283283                nice_uchars =
    284284                    udf_translate_name(unix_name, raw_name, ucode_chars);
    285                
     285
    286286                /* Output UTF-8 */
    287287                unix_name[nice_uchars] = 0;
    … …  
    292292                    str_size((char *) (id + 1)));
    293293        }
    294        
     294
    295295        free(raw_name);
    296296        free(unix_name);

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

    r3061bc1 ra35b458  
    6767            FLE16(long_ad->location.partition_num),
    6868            FLE32(long_ad->location.lblock_num));
    69        
     69
    7070        return instance->partitions[
    7171            FLE16(long_ad->location.partition_num)].start +
    … …  
    108108        if (!vd)
    109109                return ENOMEM;
    110        
     110
    111111        errno_t rc = udf_volume_recongnition_structure_test(service_id, addr, vd);
    112112        if (rc != EOK) {
    … …  
    114114                return rc;
    115115        }
    116        
     116
    117117        for (size_t i = 0; i < VRS_DEPTH; i++) {
    118118                addr += sizeof(udf_vrs_descriptor_t);
    119                
     119
    120120                rc = udf_volume_recongnition_structure_test(service_id, addr, vd);
    121121                if (rc != EOK) {
    … …  
    123123                        return rc;
    124124                }
    125                
     125
    126126                /*
    127127                 * UDF standard identifier. According to ECMA 167 2/9.1.2
    … …  
    133133                        continue;
    134134                }
    135                
     135
    136136                if (str_lcmp(VRS_END, (char *) vd->identifier, VRS_ID_LEN) == 0) {
    137137                        log_msg(LOG_DEFAULT, LVL_DEBUG, "VRS: end found");
    … …  
    139139                }
    140140        }
    141        
     141
    142142        free(vd);
    143        
     143
    144144        if (nsr_found)
    145145                return EOK;
    … …  
    178178        if (rc != EOK)
    179179                return rc;
    180        
     180
    181181        if (avd->tag.checksum != udf_tag_checksum((uint8_t *) &avd->tag))
    182182                return EINVAL;
    183        
     183
    184184        // TODO: Should be tested in big-endian mode
    185185        udf_prepare_tag(&avd->tag);
    186        
     186
    187187        if (avd->tag.id != UDF_TAG_AVDP)
    188188                return EINVAL;
    189        
     189
    190190        GET_LE32(avd->main_extent.length);
    191191        GET_LE32(avd->main_extent.location);
    192192        GET_LE32(avd->reserve_extent.length);
    193193        GET_LE32(avd->reserve_extent.location);
    194        
     194
    195195        return EOK;
    196196}
    … …  
    211211{
    212212        uint32_t default_sector_size[] = {512, 1024, 2048, 4096, 8192, 0};
    213        
     213
    214214        udf_instance_t *instance;
    215215        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    216216        if (rc != EOK)
    217217                return rc;
    218        
     218
    219219        if (instance->sector_size) {
    220220                return udf_get_anchor_volume_descriptor_by_ssize(service_id, avd,
    … …  
    229229                                return EOK;
    230230                        }
    231                        
     231
    232232                        i++;
    233233                }
    234234        }
    235        
     235
    236236        return EINVAL;
    237237}
    … …  
    273273                }
    274274        }
    275        
     275
    276276        return false;
    277277}
    … …  
    310310                }
    311311        }
    312        
     312
    313313        return false;
    314314}
    … …  
    343343                }
    344344        }
    345        
     345
    346346        return false;
    347347}
    … …  
    368368        if (rc != EOK)
    369369                return rc;
    370        
     370
    371371        udf_descriptor_tag_t *desc = (udf_descriptor_tag_t *) (block->data);
    372372        if (desc->checksum != udf_tag_checksum((uint8_t *) desc)) {
    … …  
    374374                return EINVAL;
    375375        }
    376        
     376
    377377        /*
    378378         * We think that we have only one allocator. It is means that virtual
    … …  
    383383        case UDF_FILE_ENTRY:
    384384                log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: File entry descriptor found");
    385                
     385
    386386                udf_file_entry_descriptor_t *fed =
    387387                    (udf_file_entry_descriptor_t *) block->data;
    … …  
    392392                instance->partitions[id].lenght = FLE32(short_d->length);
    393393                break;
    394                
     394
    395395        case UDF_EFILE_ENTRY:
    396396                log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: Extended file entry descriptor found");
    397                
     397
    398398                udf_extended_file_entry_descriptor_t *efed =
    399399                    (udf_extended_file_entry_descriptor_t *) block->data;
    … …  
    404404                break;
    405405        }
    406        
     406
    407407        return block_put(block);
    408408}
    … …  
    426426                        return i;
    427427        }
    428        
     428
    429429        return (size_t) -1;
    430430}
    … …  
    448448        if (instance->volumes == NULL)
    449449                return ENOMEM;
    450        
     450
    451451        instance->partitions = calloc(pd_cnt, sizeof(udf_partition_t));
    452452        if (instance->partitions == NULL) {
    … …  
    454454                return ENOMEM;
    455455        }
    456        
     456
    457457        instance->partition_cnt = pd_cnt;
    458        
     458
    459459        /*
    460460         * Fill information about logical volumes. We will save
    461461         * information about all partitions placed inside each volumes.
    462462         */
    463        
     463
    464464        size_t vir_pd_cnt = 0;
    465465        for (size_t i = 0; i < lvd_cnt; i++) {
    … …  
    471471                        return ENOMEM;
    472472                }
    473                
     473
    474474                instance->volumes[i].partition_cnt = 0;
    475475                instance->volumes[i].logical_block_size =
    476476                    FLE32(lvd[i].logical_block_size);
    477                
     477
    478478                /*
    479479                 * In theory we could have more than 1 logical volume. But now
    … …  
    481481                 * partitions from array pd belong to only first lvd
    482482                 */
    483                
     483
    484484                uint8_t *idx = lvd[i].partition_map;
    485485                for (size_t j = 0; j < FLE32(lvd[i].number_of_partitions_maps);
    … …  
    487487                        udf_type1_partition_map_t *pm1 =
    488488                            (udf_type1_partition_map_t *) idx;
    489                        
     489
    490490                        if (pm1->partition_map_type == 1) {
    491491                                size_t pd_num = udf_find_partition(pd, pd_cnt,
    … …  
    495495                                        return ENOENT;
    496496                                }
    497                                
     497
    498498                                /*
    499499                                 * Fill information about physical partitions. We will save all
    … …  
    509509                                instance->partitions[j].start =
    510510                                    FLE32(pd[pd_num].starting_location);
    511                                
     511
    512512                                instance->volumes[i].partitions[
    513513                                    instance->volumes[i].partition_cnt] =
    514514                                    &instance->partitions[j];
    515                                
     515
    516516                                log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] "
    517517                                    "found and filled", i, pm1->partition_map_type);
    518                                
     518
    519519                                instance->volumes[i].partition_cnt++;
    520520                                idx += pm1->partition_map_lenght;
    521521                                continue;
    522522                        }
    523                        
     523
    524524                        udf_type2_partition_map_t *pm2 =
    525525                            (udf_type2_partition_map_t *) idx;
    526                        
     526
    527527                        if (pm2->partition_map_type == 2) {
    528528                                // TODO: check partition_ident for metadata_partition_map
    529                                
     529
    530530                                udf_metadata_partition_map_t *metadata =
    531531                                    (udf_metadata_partition_map_t *) idx;
    532                                
     532
    533533                                log_msg(LOG_DEFAULT, LVL_DEBUG, "Metadata file location=%u",
    534534                                    FLE32(metadata->metadata_fileloc));
    535                                
     535
    536536                                vir_pd_cnt++;
    537537                                instance->partitions = realloc(instance->partitions,
    … …  
    541541                                        return ENOMEM;
    542542                                }
    543                                
     543
    544544                                instance->partition_cnt++;
    545                                
     545
    546546                                size_t pd_num = udf_find_partition(pd, pd_cnt,
    547547                                    FLE16(metadata->partition_number));
    … …  
    550550                                        return ENOENT;
    551551                                }
    552                                
     552
    553553                                instance->partitions[j].number =
    554554                                    FLE16(metadata->partition_number);
    … …  
    560560                                        return rc;
    561561                                }
    562                                
     562
    563563                                /* Virtual partition placed inside physical */
    564564                                instance->partitions[j].start +=
    565565                                    FLE32(pd[pd_num].starting_location);
    566                                
     566
    567567                                instance->volumes[i].partitions[
    568568                                    instance->volumes[i].partition_cnt] =
    569569                                    &instance->partitions[j];
    570                                
     570
    571571                                log_msg(LOG_DEFAULT, LVL_DEBUG, "Virtual partition: num=%d, start=%d",
    572572                                    instance->partitions[j].number,
    … …  
    574574                                log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] "
    575575                                    "found and filled", i, pm2->partition_map_type);
    576                                
     576
    577577                                instance->volumes[i].partition_cnt++;
    578578                                idx += metadata->partition_map_length;
    579579                                continue;
    580580                        }
    581                        
     581
    582582                        /* Not type 1 nor type 2 */
    583583                        udf_general_type_t *pm = (udf_general_type_t *) idx;
    584                        
     584
    585585                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] "
    586586                            "found and skipped", i, pm->partition_map_type);
    587                        
     587
    588588                        idx += pm->partition_map_lenght;
    589589                }
    590590        }
    591        
     591
    592592        return EOK;
    593593}
    … …  
    608608        if (rc != EOK)
    609609                return rc;
    610        
     610
    611611        aoff64_t pos = addr.location;
    612612        aoff64_t end = pos + (addr.length / instance->sector_size) - 1;
    613        
     613
    614614        if (pos == end)
    615615                return EINVAL;
    616        
     616
    617617        size_t max_descriptors = ALL_UP(addr.length, instance->sector_size);
    618        
     618
    619619        udf_primary_volume_descriptor_t *pvd = calloc(max_descriptors,
    620620            sizeof(udf_primary_volume_descriptor_t));
    621621        if (pvd == NULL)
    622622                return ENOMEM;
    623        
     623
    624624        udf_logical_volume_descriptor_t *lvd = calloc(max_descriptors,
    625625            instance->sector_size);
    … …  
    628628                return ENOMEM;
    629629        }
    630        
     630
    631631        udf_partition_descriptor_t *pd = calloc(max_descriptors,
    632632            sizeof(udf_partition_descriptor_t));
    … …  
    636636                return ENOMEM;
    637637        }
    638        
     638
    639639        size_t pvd_cnt = 0;
    640640        size_t lvd_cnt = 0;
    641641        size_t pd_cnt = 0;
    642        
     642
    643643        while (pos <= end) {
    644644                block_t *block = NULL;
    … …  
    650650                        return rc;
    651651                }
    652                
     652
    653653                udf_volume_descriptor_t *vol =
    654654                    (udf_volume_descriptor_t *) block->data;
    655                
     655
    656656                switch (FLE16(vol->common.tag.id)) {
    657657                /* One sector size descriptors */
    658658                case UDF_TAG_PVD:
    659659                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Primary volume descriptor found");
    660                        
     660
    661661                        if (!udf_check_prevailing_pvd(pvd, pvd_cnt, &vol->volume)) {
    662662                                memcpy(&pvd[pvd_cnt], &vol->volume,
    … …  
    664664                                pvd_cnt++;
    665665                        }
    666                        
     666
    667667                        pos++;
    668668                        break;
    669                        
     669
    670670                case UDF_TAG_VDP:
    671671                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Volume descriptor pointer found");
    672672                        pos++;
    673673                        break;
    674                        
     674
    675675                case UDF_TAG_IUVD:
    676676                        log_msg(LOG_DEFAULT, LVL_DEBUG,
    … …  
    678678                        pos++;
    679679                        break;
    680                        
     680
    681681                case UDF_TAG_PD:
    682682                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Partition descriptor found");
    … …  
    688688                            FLE32(vol->partition.starting_location),
    689689                            FLE32(vol->partition.length));
    690                        
     690
    691691                        if (!udf_check_prevailing_pd(pd, pd_cnt, &vol->partition)) {
    692692                                memcpy(&pd[pd_cnt], &vol->partition,
    … …  
    694694                                pd_cnt++;
    695695                        }
    696                        
     696
    697697                        udf_partition_header_descriptor_t *phd =
    698698                            (udf_partition_header_descriptor_t *) vol->partition.contents_use;
    … …  
    702702                                    FLE32(phd->unallocated_space_table.length),
    703703                                    FLE32(phd->unallocated_space_table.position));
    704                                
     704
    705705                                instance->space_type = SPACE_TABLE;
    706706                                instance->uaspace_start =
    … …  
    710710                                    FLE32(phd->unallocated_space_table.length);
    711711                        }
    712                        
     712
    713713                        if (FLE32(phd->unallocated_space_bitmap.length)) {
    714714                                log_msg(LOG_DEFAULT, LVL_DEBUG,
    … …  
    716716                                    FLE32(phd->unallocated_space_bitmap.length),
    717717                                    FLE32(phd->unallocated_space_bitmap.position));
    718                                
     718
    719719                                instance->space_type = SPACE_BITMAP;
    720720                                instance->uaspace_start =
    … …  
    724724                                    FLE32(phd->unallocated_space_bitmap.length);
    725725                        }
    726                        
     726
    727727                        pos++;
    728728                        break;
    729                        
     729
    730730                /* Relative size descriptors */
    731731                case UDF_TAG_LVD:
    732732                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Logical volume descriptor found");
    733                        
     733
    734734                        aoff64_t sct =
    735735                            ALL_UP((sizeof(udf_logical_volume_descriptor_t) +
    … …  
    738738                        pos += sct;
    739739                        char tmp[130];
    740                        
     740
    741741                        udf_to_unix_name(tmp, 129,
    742742                            (char *) vol->logical.logical_volume_id, 128,
    743743                            &vol->logical.charset);
    744                        
     744
    745745                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Logical Volume ID: '%s', "
    746746                            "logical block size: %" PRIu32 " (bytes)", tmp,
    … …  
    750750                            FLE32(vol->logical.map_table_length),
    751751                            FLE32(vol->logical.number_of_partitions_maps));
    752                        
     752
    753753                        if (!udf_check_prevailing_lvd(lvd, lvd_cnt, &vol->logical)) {
    754754                                memcpy(&lvd[lvd_cnt], &vol->logical,
    … …  
    757757                                lvd_cnt++;
    758758                        }
    759                        
     759
    760760                        break;
    761                        
     761
    762762                case UDF_TAG_USD:
    763763                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Unallocated space descriptor found");
    764                        
     764
    765765                        sct = ALL_UP((sizeof(udf_unallocated_space_descriptor_t) +
    766766                            FLE32(vol->unallocated.allocation_descriptors_num)*
    … …  
    774774                                return ENOMEM;
    775775                        }
    776                        
     776
    777777                        memcpy(instance->uasd, block->data, instance->sector_size);
    778778                        pos += sct;
    779779                        break;
    780                        
     780
    781781                case UDF_TAG_LVID:
    782782                        log_msg(LOG_DEFAULT, LVL_DEBUG,
    783783                            "Volume: Logical volume integrity descriptor found");
    784                        
     784
    785785                        pos++;
    786786                        break;
    787                        
     787
    788788                case UDF_TAG_TD:
    789789                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Terminating descriptor found");
    790                        
     790
    791791                        /* Found terminating descriptor. Exiting */
    792792                        pos = end + 1;
    793793                        break;
    794                        
     794
    795795                default:
    796796                        pos++;
    797797                }
    798                
     798
    799799                rc = block_put(block);
    800800                if (rc != EOK) {
    … …  
    805805                }
    806806        }
    807        
     807
    808808        /* Fill the instance */
    809809        udf_fill_volume_info(lvd, lvd_cnt, pd, pd_cnt, instance);
    810        
     810
    811811        for (size_t i = 0; i < lvd_cnt; i++) {
    812812                pos = udf_long_ad_to_pos(instance,
    813813                    (udf_long_ad_t *) &lvd[i].logical_volume_conents_use);
    814                
     814
    815815                block_t *block = NULL;
    816816                rc = block_get(&block, instance->service_id, pos,
    … …  
    820820                        return rc;
    821821                }
    822                
     822
    823823                udf_descriptor_tag_t *desc = block->data;
    824                
     824
    825825                log_msg(LOG_DEFAULT, LVL_DEBUG, "First tag ID=%" PRIu16, desc->id);
    826                
     826
    827827                if (desc->checksum != udf_tag_checksum((uint8_t *) desc)) {
    828828                        // FIXME: Memory leak, cleanup missing
    829829                        return EINVAL;
    830830                }
    831                
     831
    832832                udf_prepare_tag(desc);
    833                
     833
    834834                udf_fileset_descriptor_t *fd = block->data;
    835835                memcpy((uint8_t *) &instance->charset,
    836836                    (uint8_t *) &fd->fileset_charset, sizeof(fd->fileset_charset));
    837                
     837
    838838                instance->volumes[i].root_dir = udf_long_ad_to_pos(instance,
    839839                    &fd->root_dir_icb);
    840840        }
    841        
     841
    842842        free(pvd);
    843843        free(lvd);
Note: See TracChangeset for help on using the changeset viewer.