uspace/srv/vfs/vfs_ipc.c

   1 /*
   2  * Copyright (c) 2008 Jakub Jermar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <vfs/vfs.h>
  30 #include "vfs.h"
  31
  32 #include <errno.h>
  33 #include <stdlib.h>
  34 #include <str.h>
  35 #include <vfs/canonify.h>
  36
  37 static void vfs_in_clone(cap_call_handle_t req_handle, ipc_call_t *request)
  38 {
  39         int oldfd = IPC_GET_ARG1(*request);
  40         int newfd = IPC_GET_ARG2(*request);
  41         bool desc = IPC_GET_ARG3(*request);
  42
  43         int outfd = -1;
  44         errno_t rc = vfs_op_clone(oldfd, newfd, desc, &outfd);
  45         async_answer_1(req_handle, rc, outfd);
  46 }
  47
  48 static void vfs_in_fsprobe(cap_call_handle_t req_handle, ipc_call_t *request)
  49 {
  50         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
  51         char *fs_name = NULL;
  52         cap_call_handle_t chandle;
  53         vfs_fs_probe_info_t info;
  54         size_t len;
  55         errno_t rc;
  56
  57         /*
  58          * Now we expect the client to send us data with the name of the file
  59          * system.
  60          */
  61         rc = async_data_write_accept((void **) &fs_name, true, 0,
  62             FS_NAME_MAXLEN, 0, NULL);
  63         if (rc != EOK) {
  64                 async_answer_0(req_handle, rc);
  65                 return;
  66         }
  67
  68         rc = vfs_op_fsprobe(fs_name, service_id, &info);
  69         async_answer_0(req_handle, rc);
  70         if (rc != EOK)
  71                 goto out;
  72
  73         /* Now we should get a read request */
  74         if (!async_data_read_receive(&chandle, &len))
  75                 goto out;
  76
  77         if (len > sizeof(info))
  78                 len = sizeof(info);
  79         (void) async_data_read_finalize(chandle, &info, len);
  80
  81 out:
  82         free(fs_name);
  83 }
  84
  85 static void vfs_in_fstypes(cap_call_handle_t req_handle, ipc_call_t *request)
  86 {
  87         cap_call_handle_t chandle;
  88         size_t len;
  89         vfs_fstypes_t fstypes;
  90         errno_t rc;
  91
  92         rc = vfs_get_fstypes(&fstypes);
  93         if (rc != EOK) {
  94                 async_answer_0(req_handle, ENOMEM);
  95                 return;
  96         }
  97
  98         /* Send size of the data */
  99         async_answer_1(req_handle, EOK, fstypes.size);
 100
 101         /* Now we should get a read request */
 102         if (!async_data_read_receive(&chandle, &len))
 103                 goto out;
 104
 105         if (len > fstypes.size)
 106                 len = fstypes.size;
 107         (void) async_data_read_finalize(chandle, fstypes.buf, len);
 108
 109 out:
 110         vfs_fstypes_free(&fstypes);
 111 }
 112
 113 static void vfs_in_mount(cap_call_handle_t req_handle, ipc_call_t *request)
 114 {
 115         int mpfd = IPC_GET_ARG1(*request);
 116
 117         /*
 118          * We expect the library to do the device-name to device-handle
 119          * translation for us, thus the device handle will arrive as ARG1
 120          * in the request.
 121          */
 122         service_id_t service_id = (service_id_t) IPC_GET_ARG2(*request);
 123
 124         unsigned int flags = (unsigned int) IPC_GET_ARG3(*request);
 125         unsigned int instance = IPC_GET_ARG4(*request);
 126
 127         char *opts = NULL;
 128         char *fs_name = NULL;
 129
 130         /* Now we expect to receive the mount options. */
 131         errno_t rc = async_data_write_accept((void **) &opts, true, 0,
 132             MAX_MNTOPTS_LEN, 0, NULL);
 133         if (rc != EOK) {
 134                 async_answer_0(req_handle, rc);
 135                 return;
 136         }
 137
 138         /* Now, we expect the client to send us data with the name of the file
 139          * system.
 140          */
 141         rc = async_data_write_accept((void **) &fs_name, true, 0,
 142             FS_NAME_MAXLEN, 0, NULL);
 143         if (rc != EOK) {
 144                 free(opts);
 145                 async_answer_0(req_handle, rc);
 146                 return;
 147         }
 148
 149         int outfd = 0;
 150         rc = vfs_op_mount(mpfd, service_id, flags, instance, opts, fs_name,
 151              &outfd);
 152         async_answer_1(req_handle, rc, outfd);
 153
 154         free(opts);
 155         free(fs_name);
 156 }
 157
 158 static void vfs_in_open(cap_call_handle_t req_handle, ipc_call_t *request)
 159 {
 160         int fd = IPC_GET_ARG1(*request);
 161         int mode = IPC_GET_ARG2(*request);
 162
 163         errno_t rc = vfs_op_open(fd, mode);
 164         async_answer_0(req_handle, rc);
 165 }
 166
 167 static void vfs_in_put(cap_call_handle_t req_handle, ipc_call_t *request)
 168 {
 169         int fd = IPC_GET_ARG1(*request);
 170         errno_t rc = vfs_op_put(fd);
 171         async_answer_0(req_handle, rc);
 172 }
 173
 174 static void vfs_in_read(cap_call_handle_t req_handle, ipc_call_t *request)
 175 {
 176         int fd = IPC_GET_ARG1(*request);
 177         aoff64_t pos = MERGE_LOUP32(IPC_GET_ARG2(*request),
 178             IPC_GET_ARG3(*request));
 179
 180         size_t bytes = 0;
 181         errno_t rc = vfs_op_read(fd, pos, &bytes);
 182         async_answer_1(req_handle, rc, bytes);
 183 }
 184
 185 static void vfs_in_rename(cap_call_handle_t req_handle, ipc_call_t *request)
 186 {
 187         /* The common base directory. */
 188         int basefd;
 189         char *old = NULL;
 190         char *new = NULL;
 191         errno_t rc;
 192
 193         basefd = IPC_GET_ARG1(*request);
 194
 195         /* Retrieve the old path. */
 196         rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
 197         if (rc != EOK)
 198                 goto out;
 199
 200         /* Retrieve the new path. */
 201         rc = async_data_write_accept((void **) &new, true, 0, 0, 0, NULL);
 202         if (rc != EOK)
 203                 goto out;
 204
 205         size_t olen;
 206         size_t nlen;
 207         char *oldc = canonify(old, &olen);
 208         char *newc = canonify(new, &nlen);
 209
 210         if ((!oldc) || (!newc)) {
 211                 rc = EINVAL;
 212                 goto out;
 213         }
 214
 215         assert(oldc[olen] == '\0');
 216         assert(newc[nlen] == '\0');
 217
 218         rc = vfs_op_rename(basefd, oldc, newc);
 219
 220 out:
 221         async_answer_0(req_handle, rc);
 222
 223         if (old)
 224                 free(old);
 225         if (new)
 226                 free(new);
 227 }
 228
 229 static void vfs_in_resize(cap_call_handle_t req_handle, ipc_call_t *request)
 230 {
 231         int fd = IPC_GET_ARG1(*request);
 232         int64_t size = MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
 233         errno_t rc = vfs_op_resize(fd, size);
 234         async_answer_0(req_handle, rc);
 235 }
 236
 237 static void vfs_in_stat(cap_call_handle_t req_handle, ipc_call_t *request)
 238 {
 239         int fd = IPC_GET_ARG1(*request);
 240         errno_t rc = vfs_op_stat(fd);
 241         async_answer_0(req_handle, rc);
 242 }
 243
 244 static void vfs_in_statfs(cap_call_handle_t req_handle, ipc_call_t *request)
 245 {
 246         int fd = (int) IPC_GET_ARG1(*request);
 247
 248         errno_t rc = vfs_op_statfs(fd);
 249         async_answer_0(req_handle, rc);
 250 }
 251
 252 static void vfs_in_sync(cap_call_handle_t req_handle, ipc_call_t *request)
 253 {
 254         int fd = IPC_GET_ARG1(*request);
 255         errno_t rc = vfs_op_sync(fd);
 256         async_answer_0(req_handle, rc);
 257 }
 258
 259 static void vfs_in_unlink(cap_call_handle_t req_handle, ipc_call_t *request)
 260 {
 261         int parentfd = IPC_GET_ARG1(*request);
 262         int expectfd = IPC_GET_ARG2(*request);
 263
 264         char *path;
 265         errno_t rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
 266         if (rc == EOK)
 267                 rc = vfs_op_unlink(parentfd, expectfd, path);
 268
 269         async_answer_0(req_handle, rc);
 270 }
 271
 272 static void vfs_in_unmount(cap_call_handle_t req_handle, ipc_call_t *request)
 273 {
 274         int mpfd = IPC_GET_ARG1(*request);
 275         errno_t rc = vfs_op_unmount(mpfd);
 276         async_answer_0(req_handle, rc);
 277 }
 278
 279 static void vfs_in_wait_handle(cap_call_handle_t req_handle, ipc_call_t *request)
 280 {
 281         bool high_fd = IPC_GET_ARG1(*request);
 282         int fd = -1;
 283         errno_t rc = vfs_op_wait_handle(high_fd, &fd);
 284         async_answer_1(req_handle, rc, fd);
 285 }
 286
 287 static void vfs_in_walk(cap_call_handle_t req_handle, ipc_call_t *request)
 288 {
 289         /*
 290          * Parent is our relative root for file lookup.
 291          * For defined flags, see <ipc/vfs.h>.
 292          */
 293         int parentfd = IPC_GET_ARG1(*request);
 294         int flags = IPC_GET_ARG2(*request);
 295
 296         int fd = 0;
 297         char *path;
 298         errno_t rc = async_data_write_accept((void **)&path, true, 0, 0, 0, NULL);
 299         if (rc == EOK) {
 300                 rc = vfs_op_walk(parentfd, flags, path, &fd);
 301                 free(path);
 302         }
 303         async_answer_1(req_handle, rc, fd);
 304 }
 305
 306 static void vfs_in_write(cap_call_handle_t req_handle, ipc_call_t *request)
 307 {
 308         int fd = IPC_GET_ARG1(*request);
 309         aoff64_t pos = MERGE_LOUP32(IPC_GET_ARG2(*request),
 310             IPC_GET_ARG3(*request));
 311
 312         size_t bytes = 0;
 313         errno_t rc = vfs_op_write(fd, pos, &bytes);
 314         async_answer_1(req_handle, rc, bytes);
 315 }
 316
 317 void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
 318 {
 319         bool cont = true;
 320
 321         /*
 322          * The connection was opened via the IPC_CONNECT_ME_TO call.
 323          * This call needs to be answered.
 324          */
 325         async_answer_0(icall_handle, EOK);
 326
 327         while (cont) {
 328                 ipc_call_t call;
 329                 cap_call_handle_t chandle = async_get_call(&call);
 330
 331                 if (!IPC_GET_IMETHOD(call))
 332                         break;
 333
 334                 switch (IPC_GET_IMETHOD(call)) {
 335                 case VFS_IN_CLONE:
 336                         vfs_in_clone(chandle, &call);
 337                         break;
 338                 case VFS_IN_FSPROBE:
 339                         vfs_in_fsprobe(chandle, &call);
 340                         break;
 341                 case VFS_IN_FSTYPES:
 342                         vfs_in_fstypes(chandle, &call);
 343                         break;
 344                 case VFS_IN_MOUNT:
 345                         vfs_in_mount(chandle, &call);
 346                         break;
 347                 case VFS_IN_OPEN:
 348                         vfs_in_open(chandle, &call);
 349                         break;
 350                 case VFS_IN_PUT:
 351                         vfs_in_put(chandle, &call);
 352                         break;
 353                 case VFS_IN_READ:
 354                         vfs_in_read(chandle, &call);
 355                         break;
 356                 case VFS_IN_REGISTER:
 357                         vfs_register(chandle, &call);
 358                         cont = false;
 359                         break;
 360                 case VFS_IN_RENAME:
 361                         vfs_in_rename(chandle, &call);
 362                         break;
 363                 case VFS_IN_RESIZE:
 364                         vfs_in_resize(chandle, &call);
 365                         break;
 366                 case VFS_IN_STAT:
 367                         vfs_in_stat(chandle, &call);
 368                         break;
 369                 case VFS_IN_STATFS:
 370                         vfs_in_statfs(chandle, &call);
 371                         break;
 372                 case VFS_IN_SYNC:
 373                         vfs_in_sync(chandle, &call);
 374                         break;
 375                 case VFS_IN_UNLINK:
 376                         vfs_in_unlink(chandle, &call);
 377                         break;
 378                 case VFS_IN_UNMOUNT:
 379                         vfs_in_unmount(chandle, &call);
 380                         break;
 381                 case VFS_IN_WAIT_HANDLE:
 382                         vfs_in_wait_handle(chandle, &call);
 383                         break;
 384                 case VFS_IN_WALK:
 385                         vfs_in_walk(chandle, &call);
 386                         break;
 387                 case VFS_IN_WRITE:
 388                         vfs_in_write(chandle, &call);
 389                         break;
 390                 default:
 391                         async_answer_0(chandle, ENOTSUP);
 392                         break;
 393                 }
 394         }
 395
 396         /*
 397          * Open files for this client will be cleaned up when its last
 398          * connection fibril terminates.
 399          */
 400 }