Changeset e8d5f9f in mainline


Ignore:
Timestamp:
2011-05-31T23:11:28Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5d1b3aa
Parents:
4ce90544 (diff), 25bef0ff (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~jakub/helenos/fs.

Files:
9 edited

Legend:

Unmodified
Added
Removed
  • boot/Makefile.common

    r4ce90544 re8d5f9f  
    114114        rootvirt \
    115115        test1 \
    116         test2
     116        test2 \
     117        test3
    117118
    118119RD_DRV_CFG =
  • uspace/Makefile

    r4ce90544 re8d5f9f  
    9090        drv/rootvirt \
    9191        drv/test1 \
    92         drv/test2
     92        drv/test2 \
     93        drv/test3
    9394
    9495## Networking
  • uspace/app/tester/Makefile

    r4ce90544 re8d5f9f  
    5353        mm/malloc3.c \
    5454        devs/devman1.c \
     55        devs/devman2.c \
    5556        hw/misc/virtchar1.c \
    5657        hw/serial/serial1.c
  • uspace/app/tester/tester.c

    r4ce90544 re8d5f9f  
    6767#include "hw/misc/virtchar1.def"
    6868#include "devs/devman1.def"
     69#include "devs/devman2.def"
    6970        {NULL, NULL, NULL, false}
    7071};
  • uspace/app/tester/tester.h

    r4ce90544 re8d5f9f  
    100100extern const char *test_virtchar1(void);
    101101extern const char *test_devman1(void);
     102extern const char *test_devman2(void);
    102103
    103104extern test_t tests[];
  • uspace/drv/rootvirt/devices.def

    r4ce90544 re8d5f9f  
    2121        .match_id = "virtual&test1"
    2222},
     23{
     24        .name = "test3",
     25        .match_id = "virtual&test3"
     26},
    2327#endif
  • uspace/srv/vfs/vfs.h

    r4ce90544 re8d5f9f  
    176176    vfs_pair_t *, ...);
    177177extern int vfs_open_node_internal(vfs_lookup_res_t *);
    178 extern int vfs_close_internal(vfs_file_t *);
    179178
    180179extern bool vfs_nodes_init(void);
  • uspace/srv/vfs/vfs_file.c

    r4ce90544 re8d5f9f  
    7979        for (i = 0; i < MAX_OPEN_FILES; i++) {
    8080                if (FILES[i]) {
    81                         (void) vfs_close_internal(FILES[i]);
    8281                        (void) vfs_fd_free(i);
    8382                }
     
    108107}
    109108
     109/** Close the file in the endpoint FS server. */
     110static int vfs_file_close_remote(vfs_file_t *file)
     111{
     112        ipc_call_t answer;
     113        aid_t msg;
     114        sysarg_t rc;
     115        int phone;
     116
     117        assert(!file->refcnt);
     118
     119        phone = vfs_grab_phone(file->node->fs_handle);
     120        msg = async_send_2(phone, VFS_OUT_CLOSE, file->node->devmap_handle,
     121            file->node->index, &answer);
     122        async_wait_for(msg, &rc);
     123        vfs_release_phone(file->node->fs_handle, phone);
     124
     125        return IPC_GET_ARG1(answer);
     126}
     127
     128
    110129/** Increment reference count of VFS file structure.
    111130 *
     
    125144 *                      decremented.
    126145 */
    127 static void vfs_file_delref(vfs_file_t *file)
    128 {
     146static int vfs_file_delref(vfs_file_t *file)
     147{
     148        int rc = EOK;
     149
    129150        assert(fibril_mutex_is_locked(&VFS_DATA->lock));
    130151
    131152        if (file->refcnt-- == 1) {
    132153                /*
    133                  * Lost the last reference to a file, need to drop our reference
    134                  * to the underlying VFS node.
     154                 * Lost the last reference to a file, need to close it in the
     155                 * endpoint FS and drop our reference to the underlying VFS node.
    135156                 */
     157                rc = vfs_file_close_remote(file);
    136158                vfs_node_delref(file->node);
    137159                free(file);
    138160        }
     161
     162        return rc;
    139163}
    140164
     
    201225int vfs_fd_free(int fd)
    202226{
     227        int rc;
     228
    203229        if (!vfs_files_init())
    204230                return ENOMEM;
     
    210236        }
    211237       
    212         vfs_file_delref(FILES[fd]);
     238        rc = vfs_file_delref(FILES[fd]);
    213239        FILES[fd] = NULL;
    214240        fibril_mutex_unlock(&VFS_DATA->lock);
    215241       
    216         return EOK;
     242        return rc;
    217243}
    218244
  • uspace/srv/vfs/vfs_ops.c

    r4ce90544 re8d5f9f  
    717717}
    718718
    719 int vfs_close_internal(vfs_file_t *file)
    720 {
    721         /*
    722          * Lock the open file structure so that no other thread can manipulate
    723          * the same open file at a time.
    724          */
    725         fibril_mutex_lock(&file->lock);
    726        
    727         if (file->refcnt <= 1) {
    728                 /* Only close the file on the destination FS server
    729                    if there are no more file descriptors (except the
    730                    present one) pointing to this file. */
    731                
    732                 int fs_phone = vfs_grab_phone(file->node->fs_handle);
    733                
    734                 /* Make a VFS_OUT_CLOSE request at the destination FS server. */
    735                 aid_t msg;
    736                 ipc_call_t answer;
    737                 msg = async_send_2(fs_phone, VFS_OUT_CLOSE,
    738                     file->node->devmap_handle, file->node->index, &answer);
    739                
    740                 /* Wait for reply from the FS server. */
    741                 sysarg_t rc;
    742                 async_wait_for(msg, &rc);
    743                
    744                 vfs_release_phone(file->node->fs_handle, fs_phone);
    745                 fibril_mutex_unlock(&file->lock);
    746                
    747                 return IPC_GET_ARG1(answer);
    748         }
    749        
    750         fibril_mutex_unlock(&file->lock);
    751         return EOK;
    752 }
    753 
    754719void vfs_close(ipc_callid_t rid, ipc_call_t *request)
    755720{
    756721        int fd = IPC_GET_ARG1(*request);
    757        
    758         /* Lookup the file structure corresponding to the file descriptor. */
    759         vfs_file_t *file = vfs_file_get(fd);
    760         if (!file) {
    761                 async_answer_0(rid, ENOENT);
    762                 return;
    763         }
    764        
    765         int ret = vfs_close_internal(file);
    766         if (ret != EOK)
    767                 async_answer_0(rid, ret);
    768        
    769         vfs_file_put(file);
     722        int ret;
     723       
    770724        ret = vfs_fd_free(fd);
    771725        async_answer_0(rid, ret);
     
    13691323        fibril_mutex_lock(&oldfile->lock);
    13701324       
    1371         /* Lookup an open file structure possibly corresponding to newfd. */
    1372         vfs_file_t *newfile = vfs_file_get(newfd);
    1373         if (newfile) {
    1374                 /* Close the originally opened file. */
    1375                 int ret = vfs_close_internal(newfile);
    1376                 if (ret != EOK) {
    1377                         fibril_mutex_unlock(&oldfile->lock);
    1378                         vfs_file_put(oldfile);
    1379                         vfs_file_put(newfile);
    1380                         async_answer_0(rid, ret);
    1381                         return;
    1382                 }
    1383                
    1384                 ret = vfs_fd_free(newfd);
    1385                 if (ret != EOK) {
    1386                         fibril_mutex_unlock(&oldfile->lock);
    1387                         vfs_file_put(oldfile);
    1388                         vfs_file_put(newfile);
    1389                         async_answer_0(rid, ret);
    1390                         return;
    1391                 }
    1392                 vfs_file_put(newfile);
    1393         }
     1325        /* Make sure newfd is closed. */
     1326        (void) vfs_fd_free(newfd);
    13941327       
    13951328        /* Assign the old file to newfd. */
Note: See TracChangeset for help on using the changeset viewer.