Changeset 5a6cc679 in mainline for uspace/srv/fs/udf


Ignore:
Timestamp:
2018-01-31T02:21:24Z (8 years ago)
Author:
Jenda <jenda.jzqk73@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a0a9cc2
Parents:
132ab5d1
Message:

Merge commit '50f19b7ee8e94570b5c63896736c4eb49cfa18db' into forwardport

Not all ints are converted to errno_t in xhci tree yet, however it compiles and works :)

Location:
uspace/srv/fs/udf
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r132ab5d1 r5a6cc679  
    8080        }
    8181       
    82         int rc = fs_register(vfs_sess, &udf_vfs_info, &udf_ops,
     82        errno_t rc = fs_register(vfs_sess, &udf_vfs_info, &udf_ops,
    8383            &udf_libfs_ops);
    8484        if (rc != EOK)

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

    r132ab5d1 r5a6cc679  
    5757 *
    5858 */
    59 static int udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag,
     59static errno_t udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag,
    6060    uint32_t pos)
    6161{
    6262        block_t *block = NULL;
    63         int rc = block_get(&block, node->instance->service_id, pos,
     63        errno_t rc = block_get(&block, node->instance->service_id, pos,
    6464            BLOCK_FLAGS_NONE);
    6565        if (rc != EOK)
    … …  
    9393 *
    9494 */
    95 int udf_read_allocation_sequence(udf_node_t *node, uint8_t *af,
     95errno_t udf_read_allocation_sequence(udf_node_t *node, uint8_t *af,
    9696    uint16_t icb_flag, uint32_t start_alloc, uint32_t len)
    9797{
    … …  
    233233 * @return    EOK on success or an error code.
    234234 */
    235 int udf_read_icb(udf_node_t *node)
     235errno_t udf_read_icb(udf_node_t *node)
    236236{
    237237        while (true) {
    … …  
    239239               
    240240                block_t *block = NULL;
    241                 int rc = block_get(&block, node->instance->service_id, pos,
     241                errno_t rc = block_get(&block, node->instance->service_id, pos,
    242242                    BLOCK_FLAGS_NONE);
    243243                if (rc != EOK)
    … …  
    303303 *
    304304 */
    305 int udf_node_get_core(udf_node_t *node)
     305errno_t udf_node_get_core(udf_node_t *node)
    306306{
    307307        node->link_cnt = 1;
    … …  
    318318 *
    319319 */
    320 static int udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid,
     320static errno_t udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid,
    321321    udf_node_t *node, aoff64_t pos)
    322322{
    … …  
    369369 *
    370370 */
    371 int udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block,
     371errno_t udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block,
    372372    udf_node_t *node, aoff64_t pos)
    373373{
    … …  
    388388 *
    389389 */
    390 int udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **fid,
     390errno_t udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **fid,
    391391    block_t **block, udf_node_t *node, aoff64_t pos)
    392392{
    … …  
    402402                size_t i = 0;
    403403                while (i * node->instance->sector_size < node->allocators[j].length) {
    404                         int rc = block_get(block, node->instance->service_id,
     404                        errno_t rc = block_get(block, node->instance->service_id,
    405405                            node->allocators[j].position + i, BLOCK_FLAGS_NONE);
    406406                        if (rc != EOK) {
    … …  
    469469 *
    470470 */
    471 int udf_get_fid_in_sector(udf_file_identifier_descriptor_t **fid,
     471errno_t udf_get_fid_in_sector(udf_file_identifier_descriptor_t **fid,
    472472    block_t **block, udf_node_t *node, aoff64_t pos, size_t *n, void **buf,
    473473    size_t *len)
    … …  
    576576 *
    577577 */
    578 int udf_read_file(size_t *read_len, ipc_callid_t callid, udf_node_t *node,
     578errno_t udf_read_file(size_t *read_len, ipc_callid_t callid, udf_node_t *node,
    579579    aoff64_t pos, size_t len)
    580580{
    … …  
    594594       
    595595        block_t *block = NULL;
    596         int rc = block_get(&block, node->instance->service_id,
     596        errno_t rc = block_get(&block, node->instance->service_id,
    597597            node->allocators[i].position + (sector_num - sector_cnt),
    598598            BLOCK_FLAGS_NONE);

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

    r132ab5d1 r5a6cc679  
    194194}__attribute__((packed)) udf_space_bitmap_descriptor_t;
    195195
    196 extern int udf_node_get_core(udf_node_t *);
    197 extern int udf_read_icb(udf_node_t *);
    198 extern int udf_read_allocation_sequence(udf_node_t *, uint8_t *, uint16_t,
     196extern errno_t udf_node_get_core(udf_node_t *);
     197extern errno_t udf_read_icb(udf_node_t *);
     198extern errno_t udf_read_allocation_sequence(udf_node_t *, uint8_t *, uint16_t,
    199199    uint32_t, uint32_t);
    200 extern int udf_read_file(size_t *, ipc_callid_t, udf_node_t *, aoff64_t,
     200extern errno_t udf_read_file(size_t *, ipc_callid_t, udf_node_t *, aoff64_t,
    201201    size_t);
    202 extern int udf_get_fid(udf_file_identifier_descriptor_t **, block_t **,
     202extern errno_t udf_get_fid(udf_file_identifier_descriptor_t **, block_t **,
    203203    udf_node_t *, aoff64_t);
    204 extern int udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **,
     204extern errno_t udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **,
    205205    block_t **, udf_node_t *, aoff64_t);
    206 extern int udf_get_fid_in_sector(udf_file_identifier_descriptor_t **,
     206extern errno_t udf_get_fid_in_sector(udf_file_identifier_descriptor_t **,
    207207    block_t **, udf_node_t *, aoff64_t, size_t *, void **, size_t *);
    208208

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

    r132ab5d1 r5a6cc679  
    9191 *
    9292 */
    93 int udf_idx_init(void)
     93errno_t udf_idx_init(void)
    9494{
    9595        if (!hash_table_create(&udf_idx, 0, 0, &udf_idx_ops))
    … …  
    104104 *
    105105 */
    106 int udf_idx_fini(void)
     106errno_t udf_idx_fini(void)
    107107{
    108108        hash_table_destroy(&udf_idx);
    … …  
    119119 *
    120120 */
    121 int udf_idx_get(udf_node_t **udfn, udf_instance_t *instance, fs_index_t index)
     121errno_t udf_idx_get(udf_node_t **udfn, udf_instance_t *instance, fs_index_t index)
    122122{
    123123        fibril_mutex_lock(&udf_idx_lock);
    … …  
    153153 *
    154154 */
    155 int udf_idx_add(udf_node_t **udfn, udf_instance_t *instance, fs_index_t index)
     155errno_t udf_idx_add(udf_node_t **udfn, udf_instance_t *instance, fs_index_t index)
    156156{
    157157        fibril_mutex_lock(&udf_idx_lock);
    … …  
    199199 *
    200200 */
    201 int udf_idx_del(udf_node_t *node)
     201errno_t udf_idx_del(udf_node_t *node)
    202202{
    203203        assert(node->ref_cnt == 0);

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

    r132ab5d1 r5a6cc679  
    3636#include "udf.h"
    3737
    38 extern int udf_idx_init(void);
    39 extern int udf_idx_fini(void);
    40 extern int udf_idx_get(udf_node_t **, udf_instance_t *, fs_index_t);
    41 extern int udf_idx_add(udf_node_t **, udf_instance_t *, fs_index_t);
    42 extern int udf_idx_del(udf_node_t *);
     38extern errno_t udf_idx_init(void);
     39extern errno_t udf_idx_fini(void);
     40extern errno_t udf_idx_get(udf_node_t **, udf_instance_t *, fs_index_t);
     41extern errno_t udf_idx_add(udf_node_t **, udf_instance_t *, fs_index_t);
     42extern errno_t udf_idx_del(udf_node_t *);
    4343
    4444#endif /* UDF_IDX_H_ */

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

    r132ab5d1 r5a6cc679  
    6868static LIST_INITIALIZE(ffn_list);
    6969
    70 static int udf_node_get(fs_node_t **rfn, service_id_t service_id,
     70static errno_t udf_node_get(fs_node_t **rfn, service_id_t service_id,
    7171    fs_index_t index)
    7272{
    7373        udf_instance_t *instance;
    74         int rc = fs_instance_get(service_id, (void **) &instance);
     74        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    7575        if (rc != EOK)
    7676                return rc;
    … …  
    9494}
    9595
    96 static int udf_root_get(fs_node_t **rfn, service_id_t service_id)
     96static errno_t udf_root_get(fs_node_t **rfn, service_id_t service_id)
    9797{
    9898        udf_instance_t *instance;
    99         int rc = fs_instance_get(service_id, (void **) &instance);
     99        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    100100        if (rc != EOK)
    101101                return rc;
    … …  
    114114}
    115115
    116 static int udf_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     116static errno_t udf_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    117117{
    118118        char *name = malloc(MAX_FILE_NAME_LEN + 1);
    … …  
    132132               
    133133                if (str_casecmp(name, component) == 0) {
    134                         int rc = udf_node_get(rfn, udf_service_get(pfn),
     134                        errno_t rc = udf_node_get(rfn, udf_service_get(pfn),
    135135                            udf_long_ad_to_pos(UDF_NODE(pfn)->instance, &long_ad));
    136136                       
    … …  
    143143               
    144144                if (block != NULL) {
    145                         int rc = block_put(block);
     145                        errno_t rc = block_put(block);
    146146                        if (rc != EOK)
    147147                                return rc;
    … …  
    155155}
    156156
    157 static int udf_node_open(fs_node_t *fn)
    158 {
    159         return EOK;
    160 }
    161 
    162 static int udf_node_put(fs_node_t *fn)
     157static errno_t udf_node_open(fs_node_t *fn)
     158{
     159        return EOK;
     160}
     161
     162static errno_t udf_node_put(fs_node_t *fn)
    163163{
    164164        udf_node_t *node = UDF_NODE(fn);
    … …  
    177177}
    178178
    179 static int udf_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    180 {
    181         return ENOTSUP;
    182 }
    183 
    184 static int udf_destroy_node(fs_node_t *fn)
    185 {
    186         return ENOTSUP;
    187 }
    188 
    189 static int udf_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    190 {
    191         return ENOTSUP;
    192 }
    193 
    194 static int udf_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    195 {
    196         return ENOTSUP;
    197 }
    198 
    199 static int udf_has_children(bool *has_children, fs_node_t *fn)
     179static errno_t udf_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     180{
     181        return ENOTSUP;
     182}
     183
     184static errno_t udf_destroy_node(fs_node_t *fn)
     185{
     186        return ENOTSUP;
     187}
     188
     189static errno_t udf_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     190{
     191        return ENOTSUP;
     192}
     193
     194static errno_t udf_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     195{
     196        return ENOTSUP;
     197}
     198
     199static errno_t udf_has_children(bool *has_children, fs_node_t *fn)
    200200{
    201201        *has_children = true;
    … …  
    248248}
    249249
    250 static int udf_size_block(service_id_t service_id, uint32_t *size)
     250static errno_t udf_size_block(service_id_t service_id, uint32_t *size)
    251251{
    252252        udf_instance_t *instance;
    253         int rc = fs_instance_get(service_id, (void **) &instance);
     253        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    254254        if (rc != EOK)
    255255                return rc;
    … …  
    263263}
    264264
    265 static int udf_total_block_count(service_id_t service_id, uint64_t *count)
     265static errno_t udf_total_block_count(service_id_t service_id, uint64_t *count)
    266266{
    267267        *count = 0;
    … …  
    270270}
    271271
    272 static int udf_free_block_count(service_id_t service_id, uint64_t *count)
     272static errno_t udf_free_block_count(service_id_t service_id, uint64_t *count)
    273273{
    274274        *count = 0;
    … …  
    299299};
    300300
    301 static int udf_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    302 {
    303         return ENOTSUP;
    304 }
    305 
    306 static int udf_mounted(service_id_t service_id, const char *opts,
     301static errno_t udf_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     302{
     303        return ENOTSUP;
     304}
     305
     306static errno_t udf_mounted(service_id_t service_id, const char *opts,
    307307    fs_index_t *index, aoff64_t *size)
    308308{
    … …  
    330330       
    331331        /* initialize block cache */
    332         int rc = block_init(service_id, MAX_SIZE);
     332        errno_t rc = block_init(service_id, MAX_SIZE);
    333333        if (rc != EOK)
    334334                return rc;
    … …  
    415415}
    416416
    417 static int udf_unmounted(service_id_t service_id)
     417static errno_t udf_unmounted(service_id_t service_id)
    418418{
    419419        fs_node_t *fn;
    420         int rc = udf_root_get(&fn, service_id);
     420        errno_t rc = udf_root_get(&fn, service_id);
    421421        if (rc != EOK)
    422422                return rc;
    … …  
    449449}
    450450
    451 static int udf_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     451static errno_t udf_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    452452    size_t *rbytes)
    453453{
    454454        udf_instance_t *instance;
    455         int rc = fs_instance_get(service_id, (void **) &instance);
     455        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    456456        if (rc != EOK)
    457457                return rc;
    … …  
    523523}
    524524
    525 static int udf_close(service_id_t service_id, fs_index_t index)
    526 {
    527         return EOK;
    528 }
    529 
    530 static int udf_sync(service_id_t service_id, fs_index_t index)
    531 {
    532         return ENOTSUP;
    533 }
    534 
    535 static int udf_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     525static errno_t udf_close(service_id_t service_id, fs_index_t index)
     526{
     527        return EOK;
     528}
     529
     530static errno_t udf_sync(service_id_t service_id, fs_index_t index)
     531{
     532        return ENOTSUP;
     533}
     534
     535static errno_t udf_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    536536    size_t *wbytes, aoff64_t *nsize)
    537537{
    … …  
    539539}
    540540
    541 static int udf_truncate(service_id_t service_id, fs_index_t index,
     541static errno_t udf_truncate(service_id_t service_id, fs_index_t index,
    542542    aoff64_t size)
    543543{
    … …  
    545545}
    546546
    547 static int udf_destroy(service_id_t service_id, fs_index_t index)
     547static errno_t udf_destroy(service_id_t service_id, fs_index_t index)
    548548{
    549549        return ENOTSUP;

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

    r132ab5d1 r5a6cc679  
    8484 *
    8585 */
    86 static int udf_volume_recongnition_structure_test(service_id_t service_id,
     86static errno_t udf_volume_recongnition_structure_test(service_id_t service_id,
    8787    aoff64_t addr, udf_vrs_descriptor_t *vd)
    8888{
    … …  
    100100 * @return    EOK on success or an error code.
    101101 */
    102 int 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;
    … …  
    109109                return ENOMEM;
    110110       
    111         int rc = udf_volume_recongnition_structure_test(service_id, addr, vd);
     111        errno_t rc = udf_volume_recongnition_structure_test(service_id, addr, vd);
    112112        if (rc != EOK) {
    113113                free(vd);
    … …  
    170170 *
    171171 */
    172 static int udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id,
     172static errno_t udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id,
    173173    udf_anchor_volume_descriptor_t *avd, uint32_t sector_size)
    174174{
    175         int rc = block_read_bytes_direct(service_id,
     175        errno_t rc = block_read_bytes_direct(service_id,
    176176            UDF_AVDP_SECTOR * sector_size,
    177177            sizeof(udf_anchor_volume_descriptor_t), avd);
    … …  
    207207 *
    208208 */
    209 int udf_get_anchor_volume_descriptor(service_id_t service_id,
     209errno_t udf_get_anchor_volume_descriptor(service_id_t service_id,
    210210    udf_anchor_volume_descriptor_t *avd)
    211211{
    … …  
    213213       
    214214        udf_instance_t *instance;
    215         int rc = fs_instance_get(service_id, (void **) &instance);
     215        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    216216        if (rc != EOK)
    217217                return rc;
    … …  
    360360 *
    361361 */
    362 static int udf_read_virtual_partition(udf_instance_t *instance, uint32_t pos,
     362static errno_t udf_read_virtual_partition(udf_instance_t *instance, uint32_t pos,
    363363    uint32_t id)
    364364{
    365365        block_t *block = NULL;
    366         int rc = block_get(&block, instance->service_id, pos,
     366        errno_t rc = block_get(&block, instance->service_id, pos,
    367367            BLOCK_FLAGS_NONE);
    368368        if (rc != EOK)
    … …  
    441441 *
    442442 */
    443 static int udf_fill_volume_info(udf_logical_volume_descriptor_t *lvd,
     443static errno_t udf_fill_volume_info(udf_logical_volume_descriptor_t *lvd,
    444444    size_t lvd_cnt, udf_partition_descriptor_t *pd, size_t pd_cnt,
    445445    udf_instance_t *instance)
    … …  
    553553                                instance->partitions[j].number =
    554554                                    FLE16(metadata->partition_number);
    555                                 int rc = udf_read_virtual_partition(instance,
     555                                errno_t rc = udf_read_virtual_partition(instance,
    556556                                    FLE32(metadata->metadata_fileloc) +
    557557                                    FLE32(pd[pd_num].starting_location), j);
    … …  
    601601 *
    602602 */
    603 int udf_read_volume_descriptor_sequence(service_id_t service_id,
     603errno_t udf_read_volume_descriptor_sequence(service_id_t service_id,
    604604    udf_extent_t addr)
    605605{
    606606        udf_instance_t *instance;
    607         int rc = fs_instance_get(service_id, (void **) &instance);
     607        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    608608        if (rc != EOK)
    609609                return rc;

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

    r132ab5d1 r5a6cc679  
    212212} __attribute__((packed)) udf_partition_header_descriptor_t;
    213213
    214 extern int udf_volume_recongnition(service_id_t);
    215 extern int udf_get_anchor_volume_descriptor(service_id_t,
     214extern errno_t udf_volume_recongnition(service_id_t);
     215extern errno_t udf_get_anchor_volume_descriptor(service_id_t,
    216216    udf_anchor_volume_descriptor_t *);
    217 extern int udf_read_volume_descriptor_sequence(service_id_t, udf_extent_t);
     217extern errno_t udf_read_volume_descriptor_sequence(service_id_t, udf_extent_t);
    218218extern fs_index_t udf_long_ad_to_pos(udf_instance_t *, udf_long_ad_t *);
    219219
Note: See TracChangeset for help on using the changeset viewer.