Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/vfs/vfs.c

    rcde999a r8d2dd7f2  
    8686 * and consume system resources.
    8787 *
    88  * Functions that return int return an error code on error and do not
     88 * Functions that return int return a negative error code on error and do not
    8989 * set errno. Depending on function, success is signalled by returning either
    9090 * EOK or a non-negative file handle.
    … …  
    104104 *      aoff64_t pos = 42;
    105105 *      char buf[512];
    106  *      size_t nread;
    107  *      rc = vfs_read(file, &pos, buf, sizeof(buf), &nread);
    108  *      if (rc != EOK) {
     106 *      ssize_t size = vfs_read(file, &pos, buf, sizeof(buf));
     107 *      if (size < 0) {
    109108 *              vfs_put(file);
    110  *              return rc;
     109 *              return size;
    111110 *      }
    112111 *
    113  *      // buf is now filled with nread bytes from file
     112 *      // buf is now filled with data from file
    114113 *
    115114 *      vfs_put(file);
    … …  
    128127static int root_fd = -1;
    129128
    130 static int get_parent_and_child(const char *path, int *parent, char **child)
     129static int get_parent_and_child(const char *path, char **child)
    131130{
    132131        size_t size;
    … …  
    136135
    137136        char *slash = str_rchr(apath, L'/');
     137        int parent;
    138138        if (slash == apath) {
    139                 *parent = vfs_root();
    140                 if (*parent < 0) {
    141                         free(apath);
    142                         return EBADF;
    143                 }
     139                parent = vfs_root();
    144140                *child = apath;
    145                 return EOK;
    146141        } else {
    147142                *slash = '\0';
    148                 int rc = vfs_lookup(apath, WALK_DIRECTORY, parent);
    149                 if (rc != EOK) {
     143                parent = vfs_lookup(apath, WALK_DIRECTORY);
     144                if (parent < 0) {
    150145                        free(apath);
    151                         return rc;
     146                        return parent;
    152147                }
    153148                *slash = '/';
    … …  
    155150                free(apath);
    156151                if (!*child) {
    157                         vfs_put(*parent);
     152                        vfs_put(parent);
    158153                        return ENOMEM;
    159154                }
    160 
    161                 return rc;
    162         }
    163 
     155        }
     156
     157        return parent;
    164158}
    165159
    … …  
    236230 *                      handle will be allocated from high indices
    237231 *
    238  * @return              New file handle on success or an error code
    239  */
    240 int vfs_clone(int file_from, int file_to, bool high, int *handle)
    241 {
    242         assert(handle != NULL);
    243 
     232 * @return              New file handle on success or a negative error code
     233 */
     234int vfs_clone(int file_from, int file_to, bool high)
     235{
    244236        async_exch_t *vfs_exch = vfs_exchange_begin();
    245         sysarg_t ret;
    246         int rc = async_req_3_1(vfs_exch, VFS_IN_CLONE, (sysarg_t) file_from,
    247             (sysarg_t) file_to, (sysarg_t) high, &ret);
     237        int rc = async_req_3_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file_from,
     238            (sysarg_t) file_to, (sysarg_t) high);
    248239        vfs_exchange_end(vfs_exch);
    249 
    250         if (rc == EOK) {
    251                 *handle = ret;
    252         }
    253240        return rc;
    254241}
    … …  
    259246 * @param size          Size of @a buf
    260247 *
    261  * @return              EOK on success or a non-error code
     248 * @return              EOK on success or a non-negative error code
    262249 */
    263250int vfs_cwd_get(char *buf, size_t size)
    … …  
    280267 * @param path  Path of the new working directory
    281268 *
    282  * @return      EOK on success or an error code
     269 * @return      EOK on success or a negative error code
    283270 */
    284271int vfs_cwd_set(const char *path)
    … …  
    289276                return ENOMEM;
    290277       
    291         int fd;
    292         int rc = vfs_lookup(abs, WALK_DIRECTORY, &fd);
    293         if (rc != EOK) {
     278        int fd = vfs_lookup(abs, WALK_DIRECTORY);
     279        if (fd < 0) {
    294280                free(abs);
    295                 return rc;
     281                return fd;
    296282        }
    297283       
    … …  
    370356 * @param info    Place to store volume identification information
    371357 *
    372  * @return                      EOK on success or an error code
     358 * @return                      EOK on success or a negative error code
    373359 */
    374360int vfs_fsprobe(const char *fs_name, service_id_t serv,
    375361    vfs_fs_probe_info_t *info)
    376362{
    377         int rc;
     363        sysarg_t rc;
    378364       
    379365        ipc_call_t answer;
    … …  
    404390 *        fstypes->fstypes[0..]. To free the list use vfs_fstypes_free().
    405391 *
    406  * @return                      EOK on success or an error code
     392 * @return                      EOK on success or a negative error code
    407393 */
    408394int vfs_fstypes(vfs_fstypes_t *fstypes)
    … …  
    499485 * @param[out] linkedfd If not NULL, will receive a file handle to the linked
    500486 *                      child
    501  * @return              EOK on success or an error code
     487 * @return              EOK on success or a negative error code
    502488 */
    503489int vfs_link(int parent, const char *child, vfs_file_kind_t kind, int *linkedfd)
    504490{
    505491        int flags = (kind == KIND_DIRECTORY) ? WALK_DIRECTORY : WALK_REGULAR;
    506         int file = -1;
    507         int rc = vfs_walk(parent, child, WALK_MUST_CREATE | flags, &file);
    508         if (rc != EOK)
    509                 return rc;
     492        int file = vfs_walk(parent, child, WALK_MUST_CREATE | flags);
     493
     494        if (file < 0)
     495                return file;
    510496
    511497        if (linkedfd)
    … …  
    529515 * @param[out] linkedfd If not NULL, will receive a file handle to the linked
    530516 *                      child
    531  * @return              EOK on success or an error code
     517 * @return              EOK on success or a negative error code
    532518 */
    533519int vfs_link_path(const char *path, vfs_file_kind_t kind, int *linkedfd)
    534520{
    535521        char *child;
    536         int parent;
    537         int rc = get_parent_and_child(path, &parent, &child);
    538         if (rc != EOK)
    539                 return rc;
    540 
    541         rc = vfs_link(parent, child, kind, linkedfd);
     522        int parent = get_parent_and_child(path, &child);
     523        if (parent < 0)
     524                return parent;
     525
     526        int rc = vfs_link(parent, child, kind, linkedfd);
    542527
    543528        free(child);
    544529        vfs_put(parent);
    545530        return rc;
    546 }
     531}       
    547532
    548533/** Lookup a path relative to the local root
    … …  
    550535 * @param path  Path to be looked up
    551536 * @param flags Walk flags
    552  * @param[out] handle Pointer to variable where handle is to be written.
    553  *
    554  * @return      EOK on success or an error code.
    555  */
    556 int vfs_lookup(const char *path, int flags, int *handle)
     537 *
     538 * @return      File handle representing the result on success or a negative
     539 *              error code on error
     540 */
     541int vfs_lookup(const char *path, int flags)
    557542{
    558543        size_t size;
    … …  
    560545        if (!p)
    561546                return ENOMEM;
    562 
    563547        int root = vfs_root();
    564548        if (root < 0) {
    … …  
    566550                return ENOENT;
    567551        }
    568 
    569         // XXX: Workaround for GCC diagnostics.
    570         *handle = -1;
    571 
    572         int rc = vfs_walk(root, p, flags, handle);
     552        int rc = vfs_walk(root, p, flags);
    573553        vfs_put(root);
    574554        free(p);
    … …  
    583563 * @param flags Walk flags
    584564 * @param mode  Mode in which to open file in
    585  * @param[out] handle Pointer to variable where handle is to be written.
    586  *
    587  * @return      EOK on success or an error code
    588  */
    589 int vfs_lookup_open(const char *path, int flags, int mode, int *handle)
    590 {
    591         int file;
    592         int rc = vfs_lookup(path, flags, &file);
    593         if (rc != EOK)
    594                 return rc;
    595 
    596         rc = vfs_open(file, mode);
     565 *
     566 * @return      EOK on success or a negative error code
     567 */
     568int vfs_lookup_open(const char *path, int flags, int mode)
     569{
     570        int file = vfs_lookup(path, flags);
     571        if (file < 0)
     572                return file;
     573
     574        int rc = vfs_open(file, mode);
    597575        if (rc != EOK) {
    598576                vfs_put(file);
    599577                return rc;
    600578        }
    601 
    602         *handle = file;
    603         return EOK;
     579       
     580        return file;
    604581}
    605582
    … …  
    614591 * @param[out] mountedfd        File handle of the mounted root if not NULL
    615592 *
    616  * @return                      EOK on success or an error code
     593 * @return                      EOK on success or a negative error code
    617594 */
    618595int vfs_mount(int mp, const char *fs_name, service_id_t serv, const char *opts,
    619596    unsigned int flags, unsigned int instance, int *mountedfd)
    620597{
    621         int rc, rc1;
     598        sysarg_t rc, rc1;
    622599       
    623600        if (!mountedfd)
    … …  
    658635 * @param[in] instance          Instance number of the file system server
    659636 *
    660  * @return                      EOK on success or an error code
     637 * @return                      EOK on success or a negative error code
    661638 */
    662639int vfs_mount_path(const char *mp, const char *fs_name, const char *fqsn,
    … …  
    729706                }
    730707               
    731                 int mpfd;
    732                 rc = vfs_walk(root_fd, mpa, WALK_DIRECTORY, &mpfd);
    733                 if (rc == EOK) {
     708                int mpfd = vfs_walk(root_fd, mpa, WALK_DIRECTORY);
     709                if (mpfd >= 0) {
    734710                        rc = vfs_mount(mpfd, fs_name, service_id, opts, flags,
    735711                            instance, NULL);
    736712                        vfs_put(mpfd);
     713                } else {
     714                        rc = mpfd;
    737715                }
    738716        }
    … …  
    752730 * @param mode  Mode in which to open file in
    753731 *
    754  * @return      EOK on success or an error code
     732 * @return      EOK on success or a negative error code
    755733 */
    756734int vfs_open(int file, int mode)
    … …  
    769747 * @param exch          Exchange to the acceptor
    770748 *
    771  * @return              EOK on success or an error code
     749 * @return              EOK on success or a negative error code
    772750 */
    773751int vfs_pass_handle(async_exch_t *vfs_exch, int file, async_exch_t *exch)
    … …  
    781759 * @param file  File handle to put
    782760 *
    783  * @return      EOK on success or an error code
     761 * @return      EOK on success or a negative error code
    784762 */
    785763int vfs_put(int file)
    … …  
    796774 * @param high   If true, the received file handle will be allocated from high
    797775 *               indices
    798  * @param[out] handle  Received handle.
    799  *
    800  * @return       EOK on success or an error code
    801  */
    802 int vfs_receive_handle(bool high, int *handle)
     776 *
     777 * @return       EOK on success or a negative error code
     778 */
     779int vfs_receive_handle(bool high)
    803780{
    804781        ipc_callid_t callid;
    … …  
    813790
    814791        sysarg_t ret;
    815         int rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE, high, &ret);
     792        sysarg_t rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE, high, &ret);
    816793
    817794        async_exchange_end(vfs_exch);
    818795
    819         if (rc == EOK) {
    820                 *handle = (int) ret;
    821         }
    822 
    823         return rc;
     796        if (rc != EOK)
     797                return rc;
     798        return ret;
    824799}
    825800
    … …  
    833808 * @param buf           Buffer, @a nbytes bytes long
    834809 * @param nbytes        Number of bytes to read
    835  * @param nread         Place to store number of bytes actually read
    836  *
    837  * @return              On success, EOK and @a *nread is filled with number
    838  *                      of bytes actually read.
    839  * @return              On failure, an error code
    840  */
    841 int vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte, size_t *nread)
     810 *
     811 * @return              On success, non-negative number of bytes read
     812 * @return              On failure, a negative error code
     813 */
     814ssize_t vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte)
    842815{
    843816        ssize_t cnt = 0;
    844         size_t nr = 0;
     817        size_t nread = 0;
    845818        uint8_t *bp = (uint8_t *) buf;
    846819        int rc;
    … …  
    848821        do {
    849822                bp += cnt;
    850                 nr += cnt;
     823                nread += cnt;
    851824                *pos += cnt;
    852                 rc = vfs_read_short(file, *pos, bp, nbyte - nr, &cnt);
    853         } while (rc == EOK && cnt > 0 && (nbyte - nr - cnt) > 0);
    854        
    855         if (rc != EOK) {
    856                 *nread = nr;
     825                rc = vfs_read_short(file, *pos, bp, nbyte - nread, &cnt);
     826        } while (rc == EOK && cnt > 0 && (nbyte - nread - cnt) > 0);
     827       
     828        if (rc != EOK)
    857829                return rc;
    858         }
    859        
    860         nr += cnt;
     830       
    861831        *pos += cnt;
    862         *nread = nr;
    863         return EOK;
     832        return nread + cnt;
    864833}
    865834
    … …  
    877846 * @param[out] nread    Actual number of bytes read (0 or more)
    878847 *
    879  * @return              EOK on success or an error code
     848 * @return              EOK on success or a negative error code
    880849 */
    881850int vfs_read_short(int file, aoff64_t pos, void *buf, size_t nbyte,
    882851    ssize_t *nread)
    883852{
    884         int rc;
     853        sysarg_t rc;
    885854        ipc_call_t answer;
    886855        aid_t req;
    … …  
    919888 * @param new   New path
    920889 *
    921  * @return      EOK on success or an error code
     890 * @return      EOK on success or a negative error code
    922891 */
    923892int vfs_rename_path(const char *old, const char *new)
    924893{
    925         int rc;
    926         int rc_orig;
     894        sysarg_t rc;
     895        sysarg_t rc_orig;
    927896        aid_t req;
    928897       
    … …  
    986955 * @param length        New length
    987956 *
    988  * @return              EOK on success or an error code
     957 * @return              EOK on success or a negative error code
    989958 */
    990959int vfs_resize(int file, aoff64_t length)
    … …  
    1000969/** Return a new file handle representing the local root
    1001970 *
    1002  * @return      A clone of the local root file handle or -1
     971 * @return      A clone of the local root file handle or a negative error code
    1003972 */
    1004973int vfs_root(void)
    1005974{
    1006         fibril_mutex_lock(&root_mutex);
    1007         int fd;
    1008         if (root_fd < 0) {
    1009                 fd = -1;
    1010         } else {
    1011                 int rc = vfs_clone(root_fd, -1, true, &fd);
    1012                 if (rc != EOK) {
    1013                         fd = -1;
    1014                 }
    1015         }
     975        fibril_mutex_lock(&root_mutex);
     976        int r;
     977        if (root_fd < 0)
     978                r = ENOENT;
     979        else
     980                r = vfs_clone(root_fd, -1, true);
    1016981        fibril_mutex_unlock(&root_mutex);
    1017         return fd;
     982        return r;
    1018983}
    1019984
    … …  
    1025990 *
    1026991 * @param nroot The new local root file handle
    1027  *
    1028  * @return  Error code
    1029  */
    1030 int vfs_root_set(int nroot)
    1031 {
    1032         int new_root;
    1033         int rc = vfs_clone(nroot, -1, true, &new_root);
    1034         if (rc != EOK) {
    1035                 return rc;
    1036         }
    1037 
     992 */
     993void vfs_root_set(int nroot)
     994{
    1038995        fibril_mutex_lock(&root_mutex);
    1039996        if (root_fd >= 0)
    1040997                vfs_put(root_fd);
    1041         root_fd = new_root;
     998        root_fd = vfs_clone(nroot, -1, true);
    1042999        fibril_mutex_unlock(&root_mutex);
    1043 
    1044         return EOK;
    10451000}
    10461001
    … …  
    10501005 * @param[out] stat     Place to store file information
    10511006 *
    1052  * @return              EOK on success or an error code
     1007 * @return              EOK on success or a negative error code
    10531008 */
    10541009int vfs_stat(int file, struct stat *stat)
    10551010{
    1056         int rc;
     1011        sysarg_t rc;
    10571012        aid_t req;
    10581013       
    … …  
    10641019                vfs_exchange_end(exch);
    10651020               
    1066                 int rc_orig;
     1021                sysarg_t rc_orig;
    10671022                async_wait_for(req, &rc_orig);
    10681023               
    … …  
    10841039 * @param[out] stat     Place to store file information
    10851040 *
    1086  * @return              EOK on success or an error code
     1041 * @return              EOK on success or a negative error code
    10871042 */
    10881043int vfs_stat_path(const char *path, struct stat *stat)
    10891044{
    1090         int file;
    1091         int rc = vfs_lookup(path, 0, &file);
    1092         if (rc != EOK)
    1093                 return rc;
    1094        
    1095         rc = vfs_stat(file, stat);
     1045        int file = vfs_lookup(path, 0);
     1046        if (file < 0)
     1047                return file;
     1048       
     1049        int rc = vfs_stat(file, stat);
    10961050
    10971051        vfs_put(file);
    … …  
    11051059 * @param[out] st       Buffer for storing information
    11061060 *
    1107  * @return              EOK on success or an error code
     1061 * @return              EOK on success or a negative error code
    11081062 */
    11091063int vfs_statfs(int file, struct statfs *st)
    11101064{
    1111         int rc, ret;
     1065        sysarg_t rc, ret;
    11121066        aid_t req;
    11131067
    … …  
    11301084 * @param[out] st       Buffer for storing information
    11311085 *
    1132  * @return              EOK on success or an error code
     1086 * @return              EOK on success or a negative error code
    11331087 */
    11341088int vfs_statfs_path(const char *path, struct statfs *st)
    11351089{
    1136         int file;
    1137         int rc = vfs_lookup(path, 0, &file);
    1138         if (rc != EOK)
    1139                 return rc;
    1140        
    1141         rc = vfs_statfs(file, st);
     1090        int file = vfs_lookup(path, 0);
     1091        if (file < 0)
     1092                return file;
     1093       
     1094        int rc = vfs_statfs(file, st);
    11421095
    11431096        vfs_put(file);
    … …  
    11501103 * @param file  File handle to synchronize
    11511104 *
    1152  * @return      EOK on success or an error code
     1105 * @return      EOK on success or a negative error code
    11531106 */
    11541107int vfs_sync(int file)
    … …  
    11721125 * @param expect        File handle of the unlinked child
    11731126 *
    1174  * @return              EOK on success or an error code
     1127 * @return              EOK on success or a negative error code
    11751128 */
    11761129int vfs_unlink(int parent, const char *child, int expect)
    11771130{
    1178         int rc;
     1131        sysarg_t rc;
    11791132        aid_t req;
    11801133       
    … …  
    11861139        vfs_exchange_end(exch);
    11871140       
    1188         int rc_orig;
     1141        sysarg_t rc_orig;
    11891142        async_wait_for(req, &rc_orig);
    11901143       
    … …  
    12011154 * @param path          Old path to be unlinked
    12021155 *
    1203  * @return              EOK on success or an error code
     1156 * @return              EOK on success or a negative error code
    12041157 */
    12051158int vfs_unlink_path(const char *path)
    12061159{
    1207         int expect;
    1208         int rc = vfs_lookup(path, 0, &expect);
    1209         if (rc != EOK)
    1210                 return rc;
     1160        int expect = vfs_lookup(path, 0);
     1161        if (expect < 0)
     1162                return expect;
    12111163
    12121164        char *child;
    1213         int parent;
    1214         rc = get_parent_and_child(path, &parent, &child);
    1215         if (rc != EOK) {
     1165        int parent = get_parent_and_child(path, &child);
     1166        if (parent < 0) {
    12161167                vfs_put(expect);
    1217                 return rc;
    1218         }
    1219 
    1220         rc = vfs_unlink(parent, child, expect);
     1168                return parent;
     1169        }
     1170
     1171        int rc = vfs_unlink(parent, child, expect);
    12211172       
    12221173        free(child);
    … …  
    12301181 * @param mp    File handle representing the mount-point
    12311182 *
    1232  * @return      EOK on success or an error code
     1183 * @return      EOK on success or a negative error code
    12331184 */
    12341185int vfs_unmount(int mp)
    … …  
    12441195 * @param mpp   Mount-point path
    12451196 *
    1246  * @return      EOK on success or an error code
     1197 * @return      EOK on success or a negative error code
    12471198 */
    12481199int vfs_unmount_path(const char *mpp)
    12491200{
    1250         int mp;
    1251         int rc = vfs_lookup(mpp, WALK_MOUNT_POINT | WALK_DIRECTORY, &mp);
    1252         if (rc != EOK)
    1253                 return rc;
    1254        
    1255         rc = vfs_unmount(mp);
     1201        int mp = vfs_lookup(mpp, WALK_MOUNT_POINT | WALK_DIRECTORY);
     1202        if (mp < 0)
     1203                return mp;
     1204       
     1205        int rc = vfs_unmount(mp);
    12561206        vfs_put(mp);
    12571207        return rc;
    … …  
    12631213 * @param path          Parent-relative path to be walked
    12641214 * @param flags         Flags influencing the walk
    1265  * @param[out] handle   File handle representing the result on success.
    1266  *
    1267  * @return              Error code.
    1268  */
    1269 int vfs_walk(int parent, const char *path, int flags, int *handle)
     1215 *
     1216 * @retrun              File handle representing the result on success or
     1217 *                      a negative error code on error
     1218 */
     1219int vfs_walk(int parent, const char *path, int flags)
    12701220{
    12711221        async_exch_t *exch = vfs_exchange_begin();
    … …  
    12731223        ipc_call_t answer;
    12741224        aid_t req = async_send_2(exch, VFS_IN_WALK, parent, flags, &answer);
    1275         int rc = async_data_write_start(exch, path, str_size(path));
     1225        sysarg_t rc = async_data_write_start(exch, path, str_size(path));
    12761226        vfs_exchange_end(exch);
    12771227               
    1278         int rc_orig;
     1228        sysarg_t rc_orig;
    12791229        async_wait_for(req, &rc_orig);
    12801230
    … …  
    12851235                return (int) rc;
    12861236       
    1287         *handle = (int) IPC_GET_ARG1(answer);
    1288         return EOK;
     1237        return (int) IPC_GET_ARG1(answer);
    12891238}
    12901239
    … …  
    12981247 * @param buf           Data, @a nbytes bytes long
    12991248 * @param nbytes        Number of bytes to write
    1300  * @param nwritten      Place to store number of bytes written
    1301  *
    1302  * @return              On success, EOK, @a *nwr is filled with number
    1303  *                      of bytes written
    1304  * @return              On failure, an error code
    1305  */
    1306 int vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte,
    1307     size_t *nwritten)
     1249 *
     1250 * @return              On success, non-negative number of bytes written
     1251 * @return              On failure, a negative error code
     1252 */
     1253ssize_t vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte)
    13081254{
    13091255        ssize_t cnt = 0;
    1310         ssize_t nwr = 0;
     1256        ssize_t nwritten = 0;
    13111257        const uint8_t *bp = (uint8_t *) buf;
    13121258        int rc;
    … …  
    13141260        do {
    13151261                bp += cnt;
    1316                 nwr += cnt;
     1262                nwritten += cnt;
    13171263                *pos += cnt;
    1318                 rc = vfs_write_short(file, *pos, bp, nbyte - nwr, &cnt);
    1319         } while (rc == EOK && ((ssize_t )nbyte - nwr - cnt) > 0);
    1320 
    1321         if (rc != EOK) {
    1322                 *nwritten = nwr;
     1264                rc = vfs_write_short(file, *pos, bp, nbyte - nwritten, &cnt);
     1265        } while (rc == EOK && ((ssize_t )nbyte - nwritten - cnt) > 0);
     1266
     1267        if (rc != EOK)
    13231268                return rc;
    1324         }
    1325 
    1326         nwr += cnt;
     1269
    13271270        *pos += cnt;
    1328         *nwritten = nwr;
    1329         return EOK;
     1271        return nbyte;
    13301272}
    13311273
    … …  
    13411283 * @param[out] nread    Actual number of bytes written (0 or more)
    13421284 *
    1343  * @return              EOK on success or an error code
     1285 * @return              EOK on success or a negative error code
    13441286 */
    13451287int vfs_write_short(int file, aoff64_t pos, const void *buf, size_t nbyte,
    13461288    ssize_t *nwritten)
    13471289{
    1348         int rc;
     1290        sysarg_t rc;
    13491291        ipc_call_t answer;
    13501292        aid_t req;
Note: See TracChangeset for help on using the changeset viewer.