Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    rf29a3a2 r4cac2d69  
    266266       
    267267        /* We want the client to send us the mount point. */
    268         ipc_callid_t callid;
    269         size_t size;
    270         if (!async_data_write_receive(&callid, &size)) {
    271                 ipc_answer_0(callid, EINVAL);
    272                 ipc_answer_0(rid, EINVAL);
    273                 return;
    274         }
    275        
    276         /* Check whether size is reasonable wrt. the mount point. */
    277         if ((size < 1) || (size > MAX_PATH_LEN)) {
    278                 ipc_answer_0(callid, EINVAL);
    279                 ipc_answer_0(rid, EINVAL);
    280                 return;
    281         }
    282        
    283         /* Allocate buffer for the mount point data being received. */
    284         char *mp = malloc(size + 1);
    285         if (!mp) {
    286                 ipc_answer_0(callid, ENOMEM);
    287                 ipc_answer_0(rid, ENOMEM);
    288                 return;
    289         }
    290        
    291         /* Deliver the mount point. */
    292         ipcarg_t retval = async_data_write_finalize(callid, mp, size);
    293         if (retval != EOK) {
    294                 ipc_answer_0(rid, retval);
     268        char *mp;
     269        int rc = async_data_write_accept((void **) &mp, true, 0, MAX_PATH_LEN,
     270            0, NULL);
     271        if (rc != EOK) {
     272                ipc_answer_0(rid, rc);
     273                return;
     274        }
     275       
     276        /* Now we expect to receive the mount options. */
     277        char *opts;
     278        rc = async_data_write_accept((void **) &opts, true, 0, MAX_MNTOPTS_LEN,
     279            0, NULL);
     280        if (rc != EOK) {
    295281                free(mp);
    296                 return;
    297         }
    298         mp[size] = '\0';
    299        
    300         /* Now we expect to receive the mount options. */
    301         if (!async_data_write_receive(&callid, &size)) {
    302                 ipc_answer_0(callid, EINVAL);
    303                 ipc_answer_0(rid, EINVAL);
    304                 free(mp);
    305                 return;
    306         }
    307 
    308         /* Check the offered options size. */
    309         if (size > MAX_MNTOPTS_LEN) {
    310                 ipc_answer_0(callid, EINVAL);
    311                 ipc_answer_0(rid, EINVAL);
    312                 free(mp);
    313                 return;
    314         }
    315 
    316         /* Allocate buffer for the mount options. */
    317         char *opts = (char *) malloc(size + 1);
    318         if (!opts) {
    319                 ipc_answer_0(callid, ENOMEM);
    320                 ipc_answer_0(rid, ENOMEM);
    321                 free(mp);
    322                 return;
    323         }
    324 
    325         /* Deliver the mount options. */
    326         retval = async_data_write_finalize(callid, opts, size);
    327         if (retval != EOK) {
    328                 ipc_answer_0(rid, retval);
     282                ipc_answer_0(rid, rc);
     283                return;
     284        }
     285       
     286        /*
     287         * Now, we expect the client to send us data with the name of the file
     288         * system.
     289         */
     290        char *fs_name;
     291        rc = async_data_write_accept((void **) &fs_name, true, 0, FS_NAME_MAXLEN,
     292            0, NULL);
     293        if (rc != EOK) {
    329294                free(mp);
    330295                free(opts);
    331                 return;
    332         }
    333         opts[size] = '\0';
    334        
    335         /*
    336          * Now, we expect the client to send us data with the name of the file
    337          * system.
    338          */
    339         if (!async_data_write_receive(&callid, &size)) {
    340                 ipc_answer_0(callid, EINVAL);
    341                 ipc_answer_0(rid, EINVAL);
    342                 free(mp);
    343                 free(opts);
    344                 return;
    345         }
    346        
    347         /*
    348          * Don't receive more than is necessary for storing a full file system
    349          * name.
    350          */
    351         if ((size < 1) || (size > FS_NAME_MAXLEN)) {
    352                 ipc_answer_0(callid, EINVAL);
    353                 ipc_answer_0(rid, EINVAL);
    354                 free(mp);
    355                 free(opts);
    356                 return;
    357         }
    358        
    359         /*
    360          * Allocate buffer for file system name.
    361          */
    362         char *fs_name = (char *) malloc(size + 1);
    363         if (fs_name == NULL) {
    364                 ipc_answer_0(callid, ENOMEM);
    365                 ipc_answer_0(rid, ENOMEM);
    366                 free(mp);
    367                 free(opts);
    368                 return;
    369         }
    370        
    371         /* Deliver the file system name. */
    372         retval = async_data_write_finalize(callid, fs_name, size);
    373         if (retval != EOK) {
    374                 ipc_answer_0(rid, retval);
    375                 free(mp);
    376                 free(opts);
    377                 free(fs_name);
    378                 return;
    379         }
    380         fs_name[size] = '\0';
    381 
     296                ipc_answer_0(rid, rc);
     297                return;
     298        }
     299       
    382300        /*
    383301         * Wait for IPC_M_PING so that we can return an error if we don't know
    … …  
    385303         */
    386304        ipc_call_t data;
    387         callid = async_get_call(&data);
     305        ipc_callid_t callid = async_get_call(&data);
    388306        if (IPC_GET_METHOD(data) != IPC_M_PING) {
    389307                ipc_answer_0(callid, ENOTSUP);
    … …  
    442360         * Receive the mount point path.
    443361         */
    444         rc = async_data_string_receive(&mp, MAX_PATH_LEN);
     362        rc = async_data_write_accept((void **) &mp, true, 0, MAX_PATH_LEN,
     363            0, NULL);
    445364        if (rc != EOK)
    446365                ipc_answer_0(rid, rc);
    … …  
    606525                lflag |= L_EXCLUSIVE;
    607526       
    608         ipc_callid_t callid;
    609         if (!async_data_write_receive(&callid, &len)) {
    610                 ipc_answer_0(callid, EINVAL);
    611                 ipc_answer_0(rid, EINVAL);
    612                 return;
    613         }
    614        
    615         char *path = malloc(len + 1);
    616         if (!path) {
    617                 ipc_answer_0(callid, ENOMEM);
    618                 ipc_answer_0(rid, ENOMEM);
    619                 return;
    620         }
    621        
    622         int rc;
    623         if ((rc = async_data_write_finalize(callid, path, len))) {
    624                 ipc_answer_0(rid, rc);
    625                 free(path);
    626                 return;
    627         }
    628         path[len] = '\0';
     527        char *path;
     528        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
     529        if (rc != EOK) {
     530                ipc_answer_0(rid, rc);
     531                return;
     532        }
    629533       
    630534        /*
    … …  
    894798       
    895799        /*
    896          * Now we need to receive a call with client's
    897          * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
    898          */
    899         ipc_callid_t callid;
    900         int res;
    901         if (read)
    902                 res = async_data_read_receive(&callid, NULL);
    903         else
    904                 res = async_data_write_receive(&callid, NULL);
    905         if (!res) {
    906                 ipc_answer_0(callid, EINVAL);
    907                 ipc_answer_0(rid, EINVAL);
    908                 return;
    909         }
    910        
    911         /*
    912800         * Lock the open file structure so that no other thread can manipulate
    913801         * the same open file at a time.
    … …  
    933821        }
    934822       
    935         int fs_phone = vfs_grab_phone(file->node->fs_handle);   
    936        
    937         /* Make a VFS_READ/VFS_WRITE request at the destination FS server. */
    938         aid_t msg;
    939         ipc_call_t answer;
    940         if (!read && file->append)
    941                 file->pos = file->node->size;
    942         msg = async_send_3(fs_phone, read ? VFS_OUT_READ : VFS_OUT_WRITE,
    943             file->node->dev_handle, file->node->index, file->pos, &answer);
    944        
    945         /*
    946          * Forward the IPC_M_DATA_READ/IPC_M_DATA_WRITE request to the
     823        int fs_phone = vfs_grab_phone(file->node->fs_handle);
     824       
     825        /*
     826         * Make a VFS_READ/VFS_WRITE request at the destination FS server
     827         * and forward the IPC_M_DATA_READ/IPC_M_DATA_WRITE request to the
    947828         * destination FS server. The call will be routed as if sent by
    948829         * ourselves. Note that call arguments are immutable in this case so we
    949830         * don't have to bother.
    950831         */
    951         ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    952 
    953         /* Wait for reply from the FS server. */
    954832        ipcarg_t rc;
    955         async_wait_for(msg, &rc);
     833        ipc_call_t answer;
     834        if (read) {
     835                if (file->append)
     836                        file->pos = file->node->size;
     837               
     838                rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
     839                    file->node->dev_handle, file->node->index, file->pos,
     840                    &answer);
     841        } else {
     842                rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
     843                    file->node->dev_handle, file->node->index, file->pos,
     844                    &answer);
     845        }
    956846       
    957847        vfs_release_phone(fs_phone);
    958848       
    959849        size_t bytes = IPC_GET_ARG1(answer);
    960 
     850       
    961851        if (file->node->type == VFS_NODE_DIRECTORY)
    962852                fibril_rwlock_read_unlock(&namespace_rwlock);
    … …  
    11201010void vfs_stat(ipc_callid_t rid, ipc_call_t *request)
    11211011{
    1122         size_t len;
     1012        char *path;
     1013        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
     1014        if (rc != EOK) {
     1015                ipc_answer_0(rid, rc);
     1016                return;
     1017        }
     1018       
    11231019        ipc_callid_t callid;
    1124 
    1125         if (!async_data_write_receive(&callid, &len)) {
    1126                 ipc_answer_0(callid, EINVAL);
    1127                 ipc_answer_0(rid, EINVAL);
    1128                 return;
    1129         }
    1130         char *path = malloc(len + 1);
    1131         if (!path) {
    1132                 ipc_answer_0(callid, ENOMEM);
    1133                 ipc_answer_0(rid, ENOMEM);
    1134                 return;
    1135         }
    1136         int rc;
    1137         if ((rc = async_data_write_finalize(callid, path, len))) {
    1138                 ipc_answer_0(rid, rc);
    1139                 free(path);
    1140                 return;
    1141         }
    1142         path[len] = '\0';
    1143 
    11441020        if (!async_data_read_receive(&callid, NULL)) {
    11451021                free(path);
    … …  
    11871063{
    11881064        int mode = IPC_GET_ARG1(*request);
    1189 
    1190         size_t len;
    1191         ipc_callid_t callid;
    1192 
    1193         if (!async_data_write_receive(&callid, &len)) {
    1194                 ipc_answer_0(callid, EINVAL);
    1195                 ipc_answer_0(rid, EINVAL);
    1196                 return;
    1197         }
    1198         char *path = malloc(len + 1);
    1199         if (!path) {
    1200                 ipc_answer_0(callid, ENOMEM);
    1201                 ipc_answer_0(rid, ENOMEM);
    1202                 return;
    1203         }
    1204         int rc;
    1205         if ((rc = async_data_write_finalize(callid, path, len))) {
    1206                 ipc_answer_0(rid, rc);
    1207                 free(path);
    1208                 return;
    1209         }
    1210         path[len] = '\0';
    1211 
     1065       
     1066        char *path;
     1067        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
     1068        if (rc != EOK) {
     1069                ipc_answer_0(rid, rc);
     1070                return;
     1071        }
     1072       
    12121073        /* Ignore mode for now. */
    12131074        (void) mode;
    … …  
    12241085{
    12251086        int lflag = IPC_GET_ARG1(*request);
    1226 
    1227         size_t len;
    1228         ipc_callid_t callid;
    1229 
    1230         if (!async_data_write_receive(&callid, &len)) {
    1231                 ipc_answer_0(callid, EINVAL);
    1232                 ipc_answer_0(rid, EINVAL);
    1233                 return;
    1234         }
    1235         char *path = malloc(len + 1);
    1236         if (!path) {
    1237                 ipc_answer_0(callid, ENOMEM);
    1238                 ipc_answer_0(rid, ENOMEM);
    1239                 return;
    1240         }
    1241         int rc;
    1242         if ((rc = async_data_write_finalize(callid, path, len))) {
    1243                 ipc_answer_0(rid, rc);
    1244                 free(path);
    1245                 return;
    1246         }
    1247         path[len] = '\0';
     1087       
     1088        char *path;
     1089        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
     1090        if (rc != EOK) {
     1091                ipc_answer_0(rid, rc);
     1092                return;
     1093        }
    12481094       
    12491095        fibril_rwlock_write_lock(&namespace_rwlock);
    … …  
    12741120void vfs_rename(ipc_callid_t rid, ipc_call_t *request)
    12751121{
    1276         size_t olen, nlen;
    1277         ipc_callid_t callid;
    1278         int rc;
    1279 
    12801122        /* Retrieve the old path. */
    1281         if (!async_data_write_receive(&callid, &olen)) {
    1282                 ipc_answer_0(callid, EINVAL);
    1283                 ipc_answer_0(rid, EINVAL);
    1284                 return;
    1285         }
    1286         char *old = malloc(olen + 1);
    1287         if (!old) {
    1288                 ipc_answer_0(callid, ENOMEM);
    1289                 ipc_answer_0(rid, ENOMEM);
    1290                 return;
    1291         }
    1292         if ((rc = async_data_write_finalize(callid, old, olen))) {
    1293                 ipc_answer_0(rid, rc);
     1123        char *old;
     1124        int rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL);
     1125        if (rc != EOK) {
     1126                ipc_answer_0(rid, rc);
     1127                return;
     1128        }
     1129       
     1130        /* Retrieve the new path. */
     1131        char *new;
     1132        rc = async_data_write_accept((void **) &new, true, 0, 0, 0, NULL);
     1133        if (rc != EOK) {
    12941134                free(old);
    1295                 return;
    1296         }
    1297         old[olen] = '\0';
    1298        
    1299         /* Retrieve the new path. */
    1300         if (!async_data_write_receive(&callid, &nlen)) {
    1301                 ipc_answer_0(callid, EINVAL);
    1302                 ipc_answer_0(rid, EINVAL);
    1303                 free(old);
    1304                 return;
    1305         }
    1306         char *new = malloc(nlen + 1);
    1307         if (!new) {
    1308                 ipc_answer_0(callid, ENOMEM);
    1309                 ipc_answer_0(rid, ENOMEM);
    1310                 free(old);
    1311                 return;
    1312         }
    1313         if ((rc = async_data_write_finalize(callid, new, nlen))) {
    1314                 ipc_answer_0(rid, rc);
    1315                 free(old);
    1316                 free(new);
    1317                 return;
    1318         }
    1319         new[nlen] = '\0';
    1320 
     1135                ipc_answer_0(rid, rc);
     1136                return;
     1137        }
     1138       
     1139        size_t olen;
     1140        size_t nlen;
    13211141        char *oldc = canonify(old, &olen);
    13221142        char *newc = canonify(new, &nlen);
    1323         if (!oldc || !newc) {
     1143       
     1144        if ((!oldc) || (!newc)) {
    13241145                ipc_answer_0(rid, EINVAL);
    13251146                free(old);
    … …  
    13271148                return;
    13281149        }
     1150       
    13291151        oldc[olen] = '\0';
    13301152        newc[nlen] = '\0';
     1153       
    13311154        if ((!str_lcmp(newc, oldc, str_length(oldc))) &&
    13321155            ((newc[str_length(oldc)] == '/') ||
    … …  
    13491172        vfs_lookup_res_t new_par_lr;
    13501173        fibril_rwlock_write_lock(&namespace_rwlock);
     1174       
    13511175        /* Lookup the node belonging to the old file name. */
    13521176        rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
    … …  
    13581182                return;
    13591183        }
     1184       
    13601185        vfs_node_t *old_node = vfs_node_get(&old_lr);
    13611186        if (!old_node) {
    … …  
    13661191                return;
    13671192        }
     1193       
    13681194        /* Determine the path to the parent of the node with the new name. */
    13691195        char *parentc = str_dup(newc);
    … …  
    13751201                return;
    13761202        }
     1203       
    13771204        char *lastsl = str_rchr(parentc + 1, '/');
    13781205        if (lastsl)
    … …  
    13801207        else
    13811208                parentc[1] = '\0';
     1209       
    13821210        /* Lookup parent of the new file name. */
    13831211        rc = vfs_lookup_internal(parentc, L_NONE, &new_par_lr, NULL);
    … …  
    13901218                return;
    13911219        }
     1220       
    13921221        /* Check whether linking to the same file system instance. */
    13931222        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
    … …  
    13991228                return;
    14001229        }
     1230       
    14011231        /* Destroy the old link for the new name. */
    14021232        vfs_node_t *new_node = NULL;
    14031233        rc = vfs_lookup_internal(newc, L_UNLINK, &new_lr, NULL);
     1234       
    14041235        switch (rc) {
    14051236        case ENOENT:
    … …  
    14261257                return;
    14271258        }
     1259       
    14281260        /* Create the new link for the new name. */
    14291261        rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
    … …  
    14371269                return;
    14381270        }
     1271       
    14391272        fibril_mutex_lock(&nodes_mutex);
    14401273        old_node->lnkcnt++;
    14411274        fibril_mutex_unlock(&nodes_mutex);
     1275       
    14421276        /* Destroy the link for the old name. */
    14431277        rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
    … …  
    14521286                return;
    14531287        }
     1288       
    14541289        fibril_mutex_lock(&nodes_mutex);
    14551290        old_node->lnkcnt--;
    … …  
    14571292        fibril_rwlock_write_unlock(&namespace_rwlock);
    14581293        vfs_node_put(old_node);
     1294       
    14591295        if (new_node)
    14601296                vfs_node_put(new_node);
     1297       
    14611298        free(old);
    14621299        free(new);
Note: See TracChangeset for help on using the changeset viewer.