Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 594303b in mainline


Ignore:
Timestamp:
2009-04-18T15:32:56Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
8d049ee0
Parents:
6b6e423a
Message:

Support mount options.
Let tmpfs decide whether to start empty or restored a TMPFS dump based on the mount option.

Location:
uspace
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/init/init.c

    r6b6e423a r594303b  
    4646#include <macros.h>
    4747#include <console.h>
     48#include <string.h>
    4849#include "init.h"
    4950#include "version.h"
     
    5253{
    5354        int rc = -1;
     55        char *opts = "";
    5456       
     57        if (str_cmp(fstype, "tmpfs") == 0)
     58                opts = "restore";
     59
    5560        while (rc < 0) {
    56                 rc = mount(fstype, "/", "initrd", IPC_FLAG_BLOCKING);
     61                rc = mount(fstype, "/", "initrd", opts, IPC_FLAG_BLOCKING);
    5762               
    5863                switch (rc) {
  • uspace/app/tester/vfs/vfs1.c

    r6b6e423a r594303b  
    4646        int rc;
    4747
    48         rc = mount("tmpfs", "/", "nulldev0", 0);
     48        rc = mount("tmpfs", "/", "nulldev0", "", 0);
    4949        switch (rc) {
    5050        case EOK:
  • uspace/lib/libc/generic/vfs/vfs.c

    r6b6e423a r594303b  
    156156
    157157int mount(const char *fs_name, const char *mp, const char *dev,
    158         const unsigned int flags)
     158    const char *opts, const unsigned int flags)
    159159{
    160160        int res;
     
    186186        }
    187187       
     188        rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
     189        if (rc != EOK) {
     190                async_wait_for(req, NULL);
     191                async_serialize_end();
     192                futex_up(&vfs_phone_futex);
     193                free(mpa);
     194                return (int) rc;
     195        }
     196
    188197        rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    189198        if (rc != EOK) {
  • uspace/lib/libc/include/vfs/vfs.h

    r6b6e423a r594303b  
    4040extern char *absolutize(const char *, size_t *);
    4141
    42 extern int mount(const char *, const char *, const char *,
     42extern int mount(const char *, const char *, const char *, const char *,
    4343    const unsigned int flags);
    4444
  • uspace/srv/fs/fat/fat_ops.c

    r6b6e423a r594303b  
    756756        int rc;
    757757
     758        /* accept the mount options */
     759        ipc_callid_t callid;
     760        size_t size;
     761        if (!ipc_data_write_receive(&callid, &size)) {
     762                ipc_answer_0(callid, EINVAL);
     763                ipc_answer_0(rid, EINVAL);
     764                return;
     765        }
     766        char *opts = malloc(size + 1);
     767        if (!opts) {
     768                ipc_answer_0(callid, ENOMEM);
     769                ipc_answer_0(rid, ENOMEM);
     770                return;
     771        }
     772        ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
     773        if (retval != EOK) {
     774                ipc_answer_0(rid, retval);
     775                free(opts);
     776                return;
     777        }
     778        opts[size] = '\0';
     779
    758780        /* initialize libblock */
    759781        rc = block_init(dev_handle, BS_SIZE);
  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r6b6e423a r594303b  
    400400        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    401401
     402        /* accept the mount options */
     403        ipc_callid_t callid;
     404        size_t size;
     405        if (!ipc_data_write_receive(&callid, &size)) {
     406                ipc_answer_0(callid, EINVAL);
     407                ipc_answer_0(rid, EINVAL);
     408                return;
     409        }
     410        char *opts = malloc(size + 1);
     411        if (!opts) {
     412                ipc_answer_0(callid, ENOMEM);
     413                ipc_answer_0(rid, ENOMEM);
     414                return;
     415        }
     416        ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
     417        if (retval != EOK) {
     418                ipc_answer_0(rid, retval);
     419                free(opts);
     420                return;
     421        }
     422        opts[size] = '\0';
     423
    402424        /* Initialize TMPFS. */
    403425        if (!root && !tmpfs_init()) {
     
    406428        }
    407429
    408         if (dev_handle >= 0) {
     430        if (str_cmp(opts, "restore") == 0) {
    409431                if (tmpfs_restore(dev_handle))
    410432                        ipc_answer_3(rid, EOK, root->index, root->size,
  • uspace/srv/vfs/vfs.h

    r6b6e423a r594303b  
    255255extern link_t plb_head;         /**< List of active PLB entries. */
    256256
     257#define MAX_MNTOPTS_LEN         256
     258
    257259/** Holding this rwlock prevents changes in file system namespace. */
    258260extern rwlock_t namespace_rwlock;
  • uspace/srv/vfs/vfs_ops.c

    r6b6e423a r594303b  
    6161        char *fs_name;            /**< File system name */
    6262        char *mp;                 /**< Mount point */
     63        char *opts;               /**< Mount options. */
    6364        ipc_callid_t callid;      /**< Call ID waiting for the mount */
    6465        ipc_callid_t rid;         /**< Request ID */
     
    8182
    8283static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
    83     fs_handle_t fs_handle, char *mp)
    84 {
    85         /* Resolve the path to the mountpoint. */
     84    fs_handle_t fs_handle, char *mp, char *opts)
     85{
    8686        vfs_lookup_res_t mp_res;
    8787        vfs_node_t *mp_node = NULL;
    88         int rc;
     88        ipcarg_t rc;
    8989        int phone;
     90        aid_t msg;
     91        ipc_call_t answer;
     92
     93        /* Resolve the path to the mountpoint. */
    9094        futex_down(&rootfs_futex);
    9195        if (rootfs.fs_handle) {
     
    128132                        vfs_lookup_res_t mr_res;
    129133                        vfs_node_t *mr_node;
    130                         ipcarg_t rindex;
    131                         ipcarg_t rsize;
    132                         ipcarg_t rlnkcnt;
     134                        fs_index_t rindex;
     135                        size_t rsize;
     136                        unsigned rlnkcnt;
    133137                       
    134138                        /*
     
    139143                        /* Tell the mountee that it is being mounted. */
    140144                        phone = vfs_grab_phone(fs_handle);
    141                         rc = async_req_1_3(phone, VFS_MOUNTED,
    142                             (ipcarg_t) dev_handle, &rindex, &rsize, &rlnkcnt);
     145                        msg = async_send_1(phone, VFS_MOUNTED,
     146                            (ipcarg_t) dev_handle, &answer);
     147                        /* send the mount options */
     148                        rc = ipc_data_write_start(phone, (void *)opts,
     149                            str_size(opts));
     150                        if (rc != EOK) {
     151                                async_wait_for(msg, NULL);
     152                                vfs_release_phone(phone);
     153                                futex_up(&rootfs_futex);
     154                                ipc_answer_0(rid, rc);
     155                                return;
     156                        }
     157                        async_wait_for(msg, &rc);
    143158                        vfs_release_phone(phone);
    144159                       
     
    148163                                return;
    149164                        }
     165
     166                        rindex = (fs_index_t) IPC_GET_ARG1(answer);
     167                        rsize = (size_t) IPC_GET_ARG2(answer);
     168                        rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
    150169                       
    151170                        mr_res.triplet.fs_handle = fs_handle;
    152171                        mr_res.triplet.dev_handle = dev_handle;
    153                         mr_res.triplet.index = (fs_index_t) rindex;
    154                         mr_res.size = (size_t) rsize;
    155                         mr_res.lnkcnt = (unsigned) rlnkcnt;
     172                        mr_res.triplet.index = rindex;
     173                        mr_res.size = rsize;
     174                        mr_res.lnkcnt = rlnkcnt;
    156175                        mr_res.type = VFS_NODE_DIRECTORY;
    157176                       
     
    184203       
    185204        phone = vfs_grab_phone(mp_res.triplet.fs_handle);
    186         rc = async_req_4_0(phone, VFS_MOUNT,
     205        msg = async_send_4(phone, VFS_MOUNT,
    187206            (ipcarg_t) mp_res.triplet.dev_handle,
    188207            (ipcarg_t) mp_res.triplet.index,
    189208            (ipcarg_t) fs_handle,
    190             (ipcarg_t) dev_handle);
     209            (ipcarg_t) dev_handle, &answer);
     210        /* send the mount options */
     211        rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
     212        if (rc != EOK) {
     213                async_wait_for(msg, NULL);
     214                vfs_release_phone(phone);
     215                /* Mount failed, drop reference to mp_node. */
     216                if (mp_node)
     217                        vfs_node_put(mp_node);
     218                ipc_answer_0(rid, rc);
     219                return;
     220        }
     221        async_wait_for(msg, &rc);
    191222        vfs_release_phone(phone);
    192223       
     
    217248               
    218249                /* Do the mount */
    219                 vfs_mount_internal(pr->rid, pr->dev_handle, fs_handle, pr->mp);
     250                vfs_mount_internal(pr->rid, pr->dev_handle, fs_handle, pr->mp,
     251                    pr->opts);
    220252               
    221253                free(pr->fs_name);
    222254                free(pr->mp);
     255                free(pr->opts);
    223256                list_remove(cur);
    224257                free(pr);
     
    279312        mp[size] = '\0';
    280313       
     314        /* Now we expect to receive the mount options. */
     315        if (!ipc_data_write_receive(&callid, &size)) {
     316                ipc_answer_0(callid, EINVAL);
     317                ipc_answer_0(rid, EINVAL);
     318                free(mp);
     319                return;
     320        }
     321
     322        /* Check the offered options size. */
     323        if (size < 0 || size > MAX_MNTOPTS_LEN) {
     324                ipc_answer_0(callid, EINVAL);
     325                ipc_answer_0(rid, EINVAL);
     326                free(mp);
     327                return;
     328        }
     329
     330        /* Allocate buffer for the mount options. */
     331        char *opts = (char *) malloc(size + 1);
     332        if (!opts) {
     333                ipc_answer_0(callid, ENOMEM);
     334                ipc_answer_0(rid, ENOMEM);
     335                free(mp);
     336                return;
     337        }
     338
     339        /* Deliver the mount options. */
     340        retval = ipc_data_write_finalize(callid, opts, size);
     341        if (retval != EOK) {
     342                ipc_answer_0(rid, retval);
     343                free(mp);
     344                free(opts);
     345                return;
     346        }
     347        opts[size] = '\0';
     348       
    281349        /*
    282350         * Now, we expect the client to send us data with the name of the file
     
    287355                ipc_answer_0(rid, EINVAL);
    288356                free(mp);
     357                free(opts);
    289358                return;
    290359        }
     
    298367                ipc_answer_0(rid, EINVAL);
    299368                free(mp);
     369                free(opts);
    300370                return;
    301371        }
     
    309379                ipc_answer_0(rid, ENOMEM);
    310380                free(mp);
     381                free(opts);
    311382                return;
    312383        }
     
    317388                ipc_answer_0(rid, retval);
    318389                free(mp);
     390                free(opts);
    319391                free(fs_name);
    320392                return;
     
    332404                ipc_answer_0(rid, ENOTSUP);
    333405                free(mp);
     406                free(opts);
    334407                free(fs_name);
    335408                return;
     
    352425                                free(mp);
    353426                                free(fs_name);
     427                                free(opts);
    354428                                return;
    355429                        }
     
    357431                        pr->fs_name = fs_name;
    358432                        pr->mp = mp;
     433                        pr->opts = opts;
    359434                        pr->callid = callid;
    360435                        pr->rid = rid;
     
    369444                free(mp);
    370445                free(fs_name);
     446                free(opts);
    371447                return;
    372448        }
     
    376452       
    377453        /* Do the mount */
    378         vfs_mount_internal(rid, dev_handle, fs_handle, mp);
     454        vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
    379455        free(mp);
    380456        free(fs_name);
     457        free(opts);
    381458}
    382459
Note: See TracChangeset for help on using the changeset viewer.