Changes in / [393bef1:d42976c] in mainline


Ignore:
Files:
2 added
3 deleted
45 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r393bef1 rd42976c  
    310310
    311311% Support for SMP
    312 ! [(PLATFORM=ia32&PROCESSOR!=athlon_xp)|PLATFORM=amd64|PLATFORM=sparc64|PLATFORM=ia64|(PLATFORM=mips32&MACHINE=msim)] CONFIG_SMP (y/n)
     312! [(PLATFORM=ia32&PROCESSOR!=athlon_xp)|PLATFORM=amd64|PLATFORM=sparc64|PLATFORM=ia64|(PLATFORM=mips32&MACHINE=msim)|PLATFORM=abs32le] CONFIG_SMP (y/n)
    313313
    314314% Debug build

  • defaults/special/Makefile.config

    r393bef1 rd42976c  
    44# Compiler
    55COMPILER = gcc_native
     6
     7# Support for SMP
     8CONFIG_SMP = y
    69
    710# Debug build

  • kernel/arch/abs32le/Makefile.inc

    r393bef1 rd42976c  
    4141        arch/$(KARCH)/src/userspace.c \
    4242        arch/$(KARCH)/src/cpu/cpu.c \
     43        arch/$(KARCH)/src/ddi/ddi.c \
     44        arch/$(KARCH)/src/smp/smp.c \
    4345        arch/$(KARCH)/src/mm/as.c \
    4446        arch/$(KARCH)/src/mm/frame.c \

  • kernel/arch/abs32le/include/asm.h

    r393bef1 rd42976c  
    4949
    5050
    51 static inline void cpu_halt(void)
     51static inline __attribute__((noreturn)) void cpu_halt(void)
    5252{
    5353        /* On real hardware this should stop processing further

  • kernel/arch/abs32le/include/context.h

    r393bef1 rd42976c  
    3636#define KERN_abs32le_CONTEXT_H_
    3737
    38 #ifdef KERNEL
    39 #include <arch/types.h>
    40 
    4138#define STACK_ITEM_SIZE  4
    4239#define SP_DELTA         0
    4340
    44 #define context_set(c, _pc, stack, size) \
    45         do { \
    46                 (c)->pc = (uintptr_t) (_pc); \
    47         } while (0)
    48 
    49 #endif /* KERNEL */
     41#define context_set(ctx, pc, stack, size) \
     42    context_set_generic(ctx, pc, stack, size)
    5043
    5144/*

  • kernel/arch/abs32le/include/interrupt.h

    r393bef1 rd42976c  
    4040#define IVT_ITEMS  0
    4141#define IVT_FIRST  0
     42
     43#define VECTOR_TLB_SHOOTDOWN_IPI  0
    4244
    4345/*

  • kernel/arch/abs32le/src/abs32le.c

    r393bef1 rd42976c  
    3939#include <arch/asm.h>
    4040
     41#include <func.h>
    4142#include <config.h>
     43#include <context.h>
    4244#include <interrupt.h>
    4345#include <ddi/irq.h>
    … …  
    107109}
    108110
     111void memsetb(void *dst, size_t cnt, uint8_t val)
     112{
     113        _memsetb(dst, cnt, val);
     114}
     115
     116void memsetw(void *dst, size_t cnt, uint16_t val)
     117{
     118        _memsetw(dst, cnt, val);
     119}
     120
     121void panic_printf(char *fmt, ...)
     122{
     123        va_list args;
     124       
     125        va_start(args, fmt);
     126        vprintf(fmt, args);
     127        va_end(args);
     128       
     129        halt();
     130}
     131
     132int context_save_arch(context_t *ctx)
     133{
     134        return 1;
     135}
     136
     137void context_restore_arch(context_t *ctx)
     138{
     139        while (true);
     140}
     141
    109142/** @}
    110143 */

  • kernel/arch/abs32le/src/debug/stacktrace.c

    r393bef1 rd42976c  
    2727 */
    2828
    29 /** @addtogroup ia32
     29/** @addtogroup abs32le
    3030 * @{
    3131 */
    … …  
    3838#include <typedefs.h>
    3939
    40 #define FRAME_OFFSET_FP_PREV    0
    41 #define FRAME_OFFSET_RA         1
    42 
    4340bool kernel_frame_pointer_validate(uintptr_t fp)
    4441{
    45         return fp != 0;
     42        return true;;
    4643}
    4744
    4845bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    4946{
    50         uint32_t *stack = (void *) fp;
    51         *prev = stack[FRAME_OFFSET_FP_PREV];
    5247        return true;
    5348}
    … …  
    5550bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
    5651{
    57         uint32_t *stack = (void *) fp;
    58         *ra = stack[FRAME_OFFSET_RA];
    5952        return true;
    6053}
    … …  
    6255bool uspace_frame_pointer_validate(uintptr_t fp)
    6356{
    64         return fp != 0;
     57        return true;
    6558}
    6659
    6760bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    6861{
    69         return !copy_from_uspace((void *) prev,
    70             (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
     62        return true;
    7163}
    7264
    7365bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    7466{
    75         return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
    76             sizeof(*ra));
     67        return true;
     68}
     69
     70uintptr_t frame_pointer_get(void)
     71{
     72        return 0;
     73}
     74
     75uintptr_t program_counter_get(void)
     76{
     77        return 0;
    7778}
    7879

  • kernel/arch/amd64/include/asm.h

    r393bef1 rd42976c  
    6868}
    6969
    70 static inline void cpu_halt(void)
    71 {
    72         asm volatile (
    73                 "0:\n"
    74                 "       hlt\n"
    75                 "       jmp 0b\n"
    76         );
     70static inline void __attribute__((noreturn)) cpu_halt(void)
     71{
     72        while (true) {
     73                asm volatile (
     74                        "hlt\n"
     75                );
     76        }
    7777}
    7878

  • kernel/arch/arm32/include/asm.h

    r393bef1 rd42976c  
    9696}
    9797
    98 extern void cpu_halt(void);
     98extern void cpu_halt(void) __attribute__((noreturn));
    9999extern void asm_delay_loop(uint32_t t);
    100100extern void userspace_asm(uintptr_t ustack, uintptr_t uspace_uarg,

  • kernel/arch/arm32/src/arm32.c

    r393bef1 rd42976c  
    155155void cpu_halt(void)
    156156{
    157         machine_cpu_halt();
     157        while (true)
     158                machine_cpu_halt();
    158159}
    159160
    … …  
    162163{
    163164        /* not implemented */
    164         while (1);
     165        while (true);
    165166}
    166167

  • kernel/arch/ia32/include/asm.h

    r393bef1 rd42976c  
    6060 *
    6161 */
    62 static inline void cpu_halt(void)
    63 {
    64         asm volatile (
    65                 "0:\n"
    66                 "       hlt\n"
    67                 "       jmp 0b\n"
    68         );
     62static inline __attribute__((noreturn)) void cpu_halt(void)
     63{
     64        while (true) {
     65                asm volatile (
     66                        "hlt\n"
     67                );
     68        }
    6969}
    7070

  • kernel/arch/ia64/include/asm.h

    r393bef1 rd42976c  
    428428}
    429429
    430 extern void cpu_halt(void);
     430extern void cpu_halt(void) __attribute__((noreturn));
    431431extern void cpu_sleep(void);
    432432extern void asm_delay_loop(uint32_t t);

  • kernel/arch/ia64/include/context.h

    r393bef1 rd42976c  
    4848 */
    4949#define SP_DELTA        (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
    50 
    51 #ifdef context_set
    52 #undef context_set
    53 #endif
    5450
    5551/* RSE stack starts at the bottom of memory stack. */

  • kernel/arch/mips32/include/asm.h

    r393bef1 rd42976c  
    6666}
    6767
    68 extern void cpu_halt(void);
     68extern void cpu_halt(void) __attribute__((noreturn));
    6969extern void asm_delay_loop(uint32_t t);
    7070extern void userspace_asm(uintptr_t ustack, uintptr_t uspace_uarg,

  • kernel/arch/mips32/include/context.h

    r393bef1 rd42976c  
    2727 */
    2828
    29 /** @addtogroup mips32 
     29/** @addtogroup mips32
    3030 * @{
    3131 */
    … …  
    4242 * Put one item onto the stack to support get_stack_base() and align it up.
    4343 */
    44 #define SP_DELTA        (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
    45 
     44#define SP_DELTA  (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT))
    4645
    4746#ifndef __ASM__
    4847
    4948#include <arch/types.h>
     49
     50#define context_set(ctx, pc, stack, size) \
     51    context_set_generic(ctx, pc, stack, size)
    5052
    5153/*

  • kernel/arch/ppc32/include/asm.h

    r393bef1 rd42976c  
    2727 */
    2828
    29 /** @addtogroup ppc32   
     29/** @addtogroup ppc32
    3030 * @{
    3131 */
    … …  
    146146}
    147147
    148 void cpu_halt(void);
    149 void asm_delay_loop(uint32_t t);
    150 
     148extern void cpu_halt(void) __attribute__((noreturn));
     149extern void asm_delay_loop(uint32_t t);
    151150extern void userspace_asm(uintptr_t uspace_uarg, uintptr_t stack, uintptr_t entry);
    152151
    153152static inline void pio_write_8(ioport8_t *port, uint8_t v)
    154153{
    155         *port = v;     
     154        *port = v;
    156155}
    157156
    158157static inline void pio_write_16(ioport16_t *port, uint16_t v)
    159158{
    160         *port = v;     
     159        *port = v;
    161160}
    162161
    163162static inline void pio_write_32(ioport32_t *port, uint32_t v)
    164163{
    165         *port = v;     
     164        *port = v;
    166165}
    167166
    168167static inline uint8_t pio_read_8(ioport8_t *port)
    169168{
    170         return *port; 
     169        return *port;
    171170}
    172171
    173172static inline uint16_t pio_read_16(ioport16_t *port)
    174173{
    175         return *port; 
     174        return *port;
    176175}
    177176
    178177static inline uint32_t pio_read_32(ioport32_t *port)
    179178{
    180         return *port; 
     179        return *port;
    181180}
    182181

  • kernel/arch/ppc32/include/context.h

    r393bef1 rd42976c  
    2727 */
    2828
    29 /** @addtogroup ppc32   
     29/** @addtogroup ppc32
    3030 * @{
    3131 */
    … …  
    3838#include <arch/types.h>
    3939
    40 #define SP_DELTA        16
     40#define SP_DELTA  16
     41
     42#define context_set(ctx, pc, stack, size) \
     43    context_set_generic(ctx, pc, stack, size)
    4144
    4245typedef struct {
    … …  
    6871       
    6972        ipl_t ipl;
    70 } __attribute__ ((packed)) context_t;
     73} __attribute__((packed)) context_t;
    7174
    7275#endif

  • kernel/arch/sparc64/include/asm.h

    r393bef1 rd42976c  
    430430}
    431431
    432 extern void cpu_halt(void);
     432extern void cpu_halt(void) __attribute__((noreturn));
    433433extern void cpu_sleep(void);
    434434extern void asm_delay_loop(const uint32_t usec);

  • kernel/arch/sparc64/include/context.h

    r393bef1 rd42976c  
    4242#define SP_DELTA        (STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE)
    4343
    44 #ifdef context_set
    45 #undef context_set
    46 #endif
    47 
    4844#define context_set(c, _pc, stack, size)                        \
    4945        (c)->pc = ((uintptr_t) _pc) - 8;                        \

  • kernel/generic/include/context.h

    r393bef1 rd42976c  
    2727 */
    2828
    29 /** @addtogroup generic 
     29/** @addtogroup generic
    3030 * @{
    3131 */
    … …  
    3939#include <arch/context.h>
    4040
     41#define context_set_generic(ctx, _pc, stack, size) \
     42        (ctx)->pc = (uintptr_t) (_pc); \
     43        (ctx)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA;
    4144
    42 #ifndef context_set
    43 #define context_set(c, _pc, stack, size)        \
    44         (c)->pc = (uintptr_t) (_pc);            \
    45         (c)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA;
    46 #endif /* context_set */
    47 
    48 extern int context_save_arch(context_t *c) __attribute__ ((returns_twice));
    49 extern void context_restore_arch(context_t *c) __attribute__ ((noreturn));
     45extern int context_save_arch(context_t *ctx) __attribute__((returns_twice));
     46extern void context_restore_arch(context_t *ctx) __attribute__((noreturn));
    5047
    5148/** Save register context.
    … …  
    7370 * saved like that would therefore lead to a disaster.
    7471 *
    75  * @param c             Context structure.
     72 * @param ctx Context structure.
    7673 *
    77  * @return              context_save() returns 1, context_restore() returns 0.
     74 * @return context_save() returns 1, context_restore() returns 0.
     75 *
    7876 */
    79 #define context_save(c)   context_save_arch(c)
     77#define context_save(ctx)  context_save_arch(ctx)
    8078
    8179/** Restore register context.
    … …  
    8886 * being return value.
    8987 *
    90  * @param c             Context structure.
     88 * @param ctx Context structure.
    9189 */
    92 static inline void context_restore(context_t *c)
     90static inline void context_restore(context_t *ctx)
    9391{
    94         context_restore_arch(c);
     92        context_restore_arch(ctx);
    9593}
    9694

  • kernel/generic/include/func.h

    r393bef1 rd42976c  
    4141extern atomic_t haltstate;
    4242
    43 extern void halt(void);
     43extern void halt(void) __attribute__((noreturn));
    4444extern unative_t atoi(const char *text);
    4545extern void order(const uint64_t val, uint64_t *rv, char *suffix);

  • kernel/generic/include/stacktrace.h

    r393bef1 rd42976c  
    6060 */
    6161extern uintptr_t frame_pointer_get(void);
    62 extern uintptr_t program_counter_get();
     62extern uintptr_t program_counter_get(void);
    6363
    6464extern bool kernel_frame_pointer_validate(uintptr_t);

  • tools/toolchain.sh

    r393bef1 rd42976c  
    142142       
    143143        BINUTILS_VERSION="2.20"
    144         GCC_VERSION="4.4.2"
     144        GCC_VERSION="4.4.3"
    145145       
    146146        BINUTILS="binutils-${BINUTILS_VERSION}.tar.bz2"
    … …  
    165165        echo ">>> Downloading tarballs"
    166166        download_check "${BINUTILS_SOURCE}" "${BINUTILS}" "ee2d3e996e9a2d669808713360fa96f8"
    167         download_check "${GCC_SOURCE}" "${GCC_CORE}" "d50ec5af20508974411d0c83c5f4e396"
    168         download_check "${GCC_SOURCE}" "${GCC_OBJC}" "d8d26187d386a0591222a580b5a5b3d3"
    169         download_check "${GCC_SOURCE}" "${GCC_CPP}" "43b1e4879eb282dc4b05e4c016d356d7"
     167        download_check "${GCC_SOURCE}" "${GCC_CORE}" "054b66f315b3d04ad06544ce26e72365"
     168        download_check "${GCC_SOURCE}" "${GCC_OBJC}" "34711c4de46eaf79aa018206dbec4389"
     169        download_check "${GCC_SOURCE}" "${GCC_CPP}" "cd179ec4f05ee17ce76464da25a2674c"
    170170       
    171171        echo ">>> Removing previous content"

  • uspace/app/init/init.c

    r393bef1 rd42976c  
    9494static bool mount_devfs(void)
    9595{
    96         char null[MAX_DEVICE_NAME];
    97         int null_id = devmap_null_create();
    98        
    99         if (null_id == -1) {
    100                 printf(NAME ": Unable to create null device\n");
    101                 return false;
    102         }
    103        
    104         snprintf(null, MAX_DEVICE_NAME, "null/%d", null_id);
    105         int rc = mount("devfs", DEVFS_MOUNT_POINT, null, "", IPC_FLAG_BLOCKING);
     96        int rc = mount("devfs", DEVFS_MOUNT_POINT, "", "", IPC_FLAG_BLOCKING);
    10697       
    10798        switch (rc) {
    … …  
    111102        case EBUSY:
    112103                printf(NAME ": Device filesystem already mounted\n");
    113                 devmap_null_destroy(null_id);
    114104                return false;
    115105        case ELIMIT:
    116106                printf(NAME ": Unable to mount device filesystem\n");
    117                 devmap_null_destroy(null_id);
    118107                return false;
    119108        case ENOENT:
    120109                printf(NAME ": Unknown filesystem type (devfs)\n");
    121                 devmap_null_destroy(null_id);
    122110                return false;
    123111        default:
    124112                printf(NAME ": Error mounting device filesystem (%d)\n", rc);
    125                 devmap_null_destroy(null_id);
    126113                return false;
    127114        }
    … …  
    184171{
    185172        char *argv[3];
    186         char hid_in[MAX_DEVICE_NAME];
     173        char hid_in[DEVMAP_NAME_MAXLEN];
    187174        int rc;
    188175       
    189         snprintf(hid_in, MAX_DEVICE_NAME, "%s/%s", DEVFS_MOUNT_POINT, dev);
     176        snprintf(hid_in, DEVMAP_NAME_MAXLEN, "%s/%s", DEVFS_MOUNT_POINT, dev);
    190177       
    191178        printf(NAME ": Spawning %s with %s\n", SRV_CONSOLE, hid_in);
    … …  
    209196{
    210197        char *argv[4];
    211         char term[MAX_DEVICE_NAME];
     198        char term[DEVMAP_NAME_MAXLEN];
    212199        int rc;
    213200       
    214         snprintf(term, MAX_DEVICE_NAME, "%s/%s", DEVFS_MOUNT_POINT, dev);
     201        snprintf(term, DEVMAP_NAME_MAXLEN, "%s/%s", DEVFS_MOUNT_POINT, dev);
    215202       
    216203        printf(NAME ": Spawning %s with %s %s\n", APP_GETTERM, term, app);

  • uspace/app/init/init.h

    r393bef1 rd42976c  
    3939#define NAME  "init"
    4040
    41 #define MAX_DEVICE_NAME  32
    42 
    4341#endif
    4442

  • uspace/app/tester/vfs/vfs1.c

    r393bef1 rd42976c  
    7979        TPRINTF("Created directory %s\n", MOUNT_POINT);
    8080       
    81         char null[MAX_DEVICE_NAME];
    82         int null_id = devmap_null_create();
    83        
    84         if (null_id == -1)
    85                 return "Unable to create null device";
    86        
    87         snprintf(null, MAX_DEVICE_NAME, "null/%d", null_id);
    88         int rc = mount(FS_TYPE, MOUNT_POINT, null, OPTIONS, FLAGS);
     81        int rc = mount(FS_TYPE, MOUNT_POINT, "", OPTIONS, FLAGS);
    8982        switch (rc) {
    9083        case EOK:
    91                 TPRINTF("Mounted /dev/%s as %s on %s\n", null, FS_TYPE, MOUNT_POINT);
     84                TPRINTF("Mounted %s on %s\n", FS_TYPE, MOUNT_POINT);
    9285                break;
    9386        case EBUSY:

  • uspace/lib/libc/arch/ia64/include/fibril.h

    r393bef1 rd42976c  
    5252/* Stack is divided into two equal parts (for memory stack and register stack). */
    5353#define PSTHREAD_INITIAL_STACK_DIVISION 2 
    54 
    55 #ifdef context_set
    56 #undef context_set
    57 #endif
    5854
    5955#define context_set(c, _pc, stack, size, tls)                                                           \

  • uspace/lib/libc/arch/sparc64/include/fibril.h

    r393bef1 rd42976c  
    4242#define SP_DELTA        (STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE)
    4343
    44 #ifdef context_set
    45 #undef context_set
    46 #endif
    47 
    4844#define context_set(c, _pc, stack, size, ptls) \
    4945        do { \

  • uspace/lib/libc/generic/async.c

    r393bef1 rd42976c  
    12871287}
    12881288
     1289/** Wrapper for forwarding any read request
     1290 *
     1291 *
     1292 */
     1293int async_data_read_forward_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
     1294    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
     1295{
     1296        ipc_callid_t callid;
     1297        if (!async_data_read_receive(&callid, NULL)) {
     1298                ipc_answer_0(callid, EINVAL);
     1299                return EINVAL;
     1300        }
     1301       
     1302        aid_t msg = async_send_fast(phoneid, method, arg1, arg2, arg3, arg4,
     1303            dataptr);
     1304        if (msg == 0) {
     1305                ipc_answer_0(callid, EINVAL);
     1306                return EINVAL;
     1307        }
     1308       
     1309        int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0,
     1310            IPC_FF_ROUTE_FROM_ME);
     1311        if (retval != EOK) {
     1312                ipc_answer_0(callid, retval);
     1313                return retval;
     1314        }
     1315       
     1316        ipcarg_t rc;
     1317        async_wait_for(msg, &rc);
     1318       
     1319        return (int) rc;
     1320}
     1321
    12891322/** Wrapper for making IPC_M_DATA_WRITE calls using the async framework.
    12901323 *
    1291  * @param phoneid       Phone that will be used to contact the receiving side.
    1292  * @param src           Address of the beginning of the source buffer.
    1293  * @param size          Size of the source buffer.
    1294  *
    1295  * @return              Zero on success or a negative error code from errno.h.
     1324 * @param phoneid Phone that will be used to contact the receiving side.
     1325 * @param src     Address of the beginning of the source buffer.
     1326 * @param size    Size of the source buffer.
     1327 *
     1328 * @return Zero on success or a negative error code from errno.h.
     1329 *
    12961330 */
    12971331int async_data_write_start(int phoneid, const void *src, size_t size)
    … …  
    13081342 * So far, this wrapper is to be used from within a connection fibril.
    13091343 *
    1310  * @param callid        Storage where the hash of the IPC_M_DATA_WRITE call will
    1311  *                      be stored.
    1312  * @param size          Storage where the suggested size will be stored. May be
    1313  *                      NULL
    1314  *
    1315  * @return              Non-zero on success, zero on failure.
     1344 * @param callid Storage where the hash of the IPC_M_DATA_WRITE call will
     1345 *               be stored.
     1346 * @param size   Storage where the suggested size will be stored. May be
     1347 *               NULL
     1348 *
     1349 * @return Non-zero on success, zero on failure.
     1350 *
    13161351 */
    13171352int async_data_write_receive(ipc_callid_t *callid, size_t *size)
    … …  
    13201355       
    13211356        assert(callid);
    1322 
     1357       
    13231358        *callid = async_get_call(&data);
    13241359        if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
    13251360                return 0;
     1361       
    13261362        if (size)
    13271363                *size = (size_t) IPC_GET_ARG2(data);
     1364       
    13281365        return 1;
    13291366}
    … …  
    13341371 * so that the user doesn't have to remember the meaning of each IPC argument.
    13351372 *
    1336  * @param callid        Hash of the IPC_M_DATA_WRITE call to answer.
    1337  * @param dst           Final destination address for the IPC_M_DATA_WRITE call.
    1338  * @param size          Final size for the IPC_M_DATA_WRITE call.
    1339  *
    1340  * @return              Zero on success or a value from @ref errno.h on failure.
     1373 * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
     1374 * @param dst    Final destination address for the IPC_M_DATA_WRITE call.
     1375 * @param size   Final size for the IPC_M_DATA_WRITE call.
     1376 *
     1377 * @return Zero on success or a value from @ref errno.h on failure.
     1378 *
    13411379 */
    13421380int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
    … …  
    13451383}
    13461384
    1347 /** Wrapper for receiving blobs via the async_data_write_*
     1385/** Wrapper for receiving binary data or strings
    13481386 *
    13491387 * This wrapper only makes it more comfortable to use async_data_write_*
    1350  * functions to receive blobs.
    1351  *
    1352  * @param blob     Pointer to data pointer (which should be later disposed
    1353  *                 by free()). If the operation fails, the pointer is not
    1354  *                 touched.
    1355  * @param max_size Maximum size (in bytes) of the blob to receive. 0 means
    1356  *                 no limit.
    1357  * @param received If not NULL, the size of the received data is stored here.
     1388 * functions to receive binary data or strings.
     1389 *
     1390 * @param data       Pointer to data pointer (which should be later disposed
     1391 *                   by free()). If the operation fails, the pointer is not
     1392 *                   touched.
     1393 * @param nullterm   If true then the received data is always zero terminated.
     1394 *                   This also causes to allocate one extra byte beyond the
     1395 *                   raw transmitted data.
     1396 * @param min_size   Minimum size (in bytes) of the data to receive.
     1397 * @param max_size   Maximum size (in bytes) of the data to receive. 0 means
     1398 *                   no limit.
     1399 * @param granulariy If non-zero then the size of the received data has to
     1400 *                   be divisible by this value.
     1401 * @param received   If not NULL, the size of the received data is stored here.
    13581402 *
    13591403 * @return Zero on success or a value from @ref errno.h on failure.
    13601404 *
    13611405 */
    1362 int async_data_blob_receive(char **blob, const size_t max_size, size_t *received)
     1406int async_data_write_accept(void **data, const bool nullterm,
     1407    const size_t min_size, const size_t max_size, const size_t granularity,
     1408    size_t *received)
    13631409{
    13641410        ipc_callid_t callid;
    … …  
    13691415        }
    13701416       
     1417        if (size < min_size) {
     1418                ipc_answer_0(callid, EINVAL);
     1419                return EINVAL;
     1420        }
     1421       
    13711422        if ((max_size > 0) && (size > max_size)) {
    13721423                ipc_answer_0(callid, EINVAL);
    … …  
    13741425        }
    13751426       
    1376         char *data = (char *) malloc(size);
    1377         if (data == NULL) {
     1427        if ((granularity > 0) && ((size % granularity) != 0)) {
     1428                ipc_answer_0(callid, EINVAL);
     1429                return EINVAL;
     1430        }
     1431       
     1432        void *_data;
     1433       
     1434        if (nullterm)
     1435                _data = malloc(size + 1);
     1436        else
     1437                _data = malloc(size);
     1438       
     1439        if (_data == NULL) {
    13781440                ipc_answer_0(callid, ENOMEM);
    13791441                return ENOMEM;
    13801442        }
    13811443       
    1382         int rc = async_data_write_finalize(callid, data, size);
     1444        int rc = async_data_write_finalize(callid, _data, size);
    13831445        if (rc != EOK) {
    1384                 free(data);
     1446                free(_data);
    13851447                return rc;
    13861448        }
    13871449       
    1388         *blob = data;
     1450        if (nullterm)
     1451                ((char *) _data)[size] = 0;
     1452       
     1453        *data = _data;
    13891454        if (received != NULL)
    13901455                *received = size;
    … …  
    13931458}
    13941459
    1395 /** Wrapper for receiving strings via the async_data_write_*
    1396  *
    1397  * This wrapper only makes it more comfortable to use async_data_write_*
    1398  * functions to receive strings.
    1399  *
    1400  * @param str      Pointer to string pointer (which should be later disposed
    1401  *                 by free()). If the operation fails, the pointer is not
    1402  *                 touched.
    1403  * @param max_size Maximum size (in bytes) of the string to receive. 0 means
    1404  *                 no limit.
    1405  *
    1406  * @return Zero on success or a value from @ref errno.h on failure.
    1407  *
    1408  */
    1409 int async_data_string_receive(char **str, const size_t max_size)
     1460/** Wrapper for voiding any data that is about to be received
     1461 *
     1462 * This wrapper can be used to void any pending data
     1463 *
     1464 * @param retval Error value from @ref errno.h to be returned to the caller.
     1465 *
     1466 */
     1467void async_data_write_void(const int retval)
    14101468{
    14111469        ipc_callid_t callid;
    1412         size_t size;
    1413         if (!async_data_write_receive(&callid, &size)) {
     1470        async_data_write_receive(&callid, NULL);
     1471        ipc_answer_0(callid, retval);
     1472}
     1473
     1474/** Wrapper for forwarding any data that is about to be received
     1475 *
     1476 *
     1477 */
     1478int async_data_write_forward_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
     1479    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
     1480{
     1481        ipc_callid_t callid;
     1482        if (!async_data_write_receive(&callid, NULL)) {
    14141483                ipc_answer_0(callid, EINVAL);
    14151484                return EINVAL;
    14161485        }
    14171486       
    1418         if ((max_size > 0) && (size > max_size)) {
     1487        aid_t msg = async_send_fast(phoneid, method, arg1, arg2, arg3, arg4,
     1488            dataptr);
     1489        if (msg == 0) {
    14191490                ipc_answer_0(callid, EINVAL);
    14201491                return EINVAL;
    14211492        }
    14221493       
    1423         char *data = (char *) malloc(size + 1);
    1424         if (data == NULL) {
    1425                 ipc_answer_0(callid, ENOMEM);
    1426                 return ENOMEM;
    1427         }
    1428        
    1429         int rc = async_data_write_finalize(callid, data, size);
    1430         if (rc != EOK) {
    1431                 free(data);
    1432                 return rc;
    1433         }
    1434        
    1435         data[size] = 0;
    1436         *str = data;
    1437         return EOK;
     1494        int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0,
     1495            IPC_FF_ROUTE_FROM_ME);
     1496        if (retval != EOK) {
     1497                ipc_answer_0(callid, retval);
     1498                return retval;
     1499        }
     1500       
     1501        ipcarg_t rc;
     1502        async_wait_for(msg, &rc);
     1503       
     1504        return (int) rc;
    14381505}
    14391506

  • uspace/lib/libc/generic/clipboard.c

    r393bef1 rd42976c  
    8484                clip_connect();
    8585               
    86                 aid_t req = async_send_1(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_BLOB, NULL);
     86                aid_t req = async_send_1(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA, NULL);
    8787                ipcarg_t rc = async_data_write_start(clip_phone, (void *) str, size);
    8888                if (rc != EOK) {
    … …  
    139139                        *str = sbuf;
    140140                        return EOK;
    141                 case CLIPBOARD_TAG_BLOB:
     141                case CLIPBOARD_TAG_DATA:
    142142                        sbuf = malloc(size + 1);
    143143                        if (sbuf == NULL)

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

    r393bef1 rd42976c  
    120120    const char *opts, unsigned int flags)
    121121{
    122         int res;
    123         ipcarg_t rc;
    124         ipcarg_t rc_orig;
    125         aid_t req;
     122        int null_id = -1;
     123        char null[DEVMAP_NAME_MAXLEN];
     124       
     125        if (str_cmp(fqdn, "") == 0) {
     126                /* No device specified, create a fresh
     127                   null/%d device instead */
     128                null_id = devmap_null_create();
     129               
     130                if (null_id == -1)
     131                        return ENOMEM;
     132               
     133                snprintf(null, DEVMAP_NAME_MAXLEN, "null/%d", null_id);
     134                fqdn = null;
     135        }
     136       
    126137        dev_handle_t dev_handle;
    127        
    128         res = devmap_device_get_handle(fqdn, &dev_handle, flags);
    129         if (res != EOK)
     138        int res = devmap_device_get_handle(fqdn, &dev_handle, flags);
     139        if (res != EOK) {
     140                if (null_id != -1)
     141                        devmap_null_destroy(null_id);
     142               
    130143                return res;
     144        }
    131145       
    132146        size_t mpa_size;
    133147        char *mpa = absolutize(mp, &mpa_size);
    134         if (!mpa)
    135                 return ENOMEM;
    136        
    137         futex_down(&vfs_phone_futex);
    138         async_serialize_start();
    139         vfs_connect();
    140        
    141         req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
    142         rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
     148        if (!mpa) {
     149                if (null_id != -1)
     150                        devmap_null_destroy(null_id);
     151               
     152                return ENOMEM;
     153        }
     154       
     155        futex_down(&vfs_phone_futex);
     156        async_serialize_start();
     157        vfs_connect();
     158       
     159        ipcarg_t rc_orig;
     160        aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
     161        ipcarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    143162        if (rc != EOK) {
    144163                async_wait_for(req, &rc_orig);
    … …  
    146165                futex_up(&vfs_phone_futex);
    147166                free(mpa);
     167               
     168                if (null_id != -1)
     169                        devmap_null_destroy(null_id);
     170               
    148171                if (rc_orig == EOK)
    149172                        return (int) rc;
    … …  
    158181                futex_up(&vfs_phone_futex);
    159182                free(mpa);
    160                 if (rc_orig == EOK)
    161                         return (int) rc;
    162                 else
    163                         return (int) rc_orig;
    164         }
    165 
     183               
     184                if (null_id != -1)
     185                        devmap_null_destroy(null_id);
     186               
     187                if (rc_orig == EOK)
     188                        return (int) rc;
     189                else
     190                        return (int) rc_orig;
     191        }
     192       
    166193        rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    167194        if (rc != EOK) {
    … …  
    170197                futex_up(&vfs_phone_futex);
    171198                free(mpa);
    172                 if (rc_orig == EOK)
    173                         return (int) rc;
    174                 else
    175                         return (int) rc_orig;
    176         }
    177 
     199               
     200                if (null_id != -1)
     201                        devmap_null_destroy(null_id);
     202               
     203                if (rc_orig == EOK)
     204                        return (int) rc;
     205                else
     206                        return (int) rc_orig;
     207        }
     208       
    178209        /* Ask VFS whether it likes fs_name. */
    179210        rc = async_req_0_0(vfs_phone, IPC_M_PING);
    … …  
    183214                futex_up(&vfs_phone_futex);
    184215                free(mpa);
     216               
     217                if (null_id != -1)
     218                        devmap_null_destroy(null_id);
     219               
    185220                if (rc_orig == EOK)
    186221                        return (int) rc;
    … …  
    193228        futex_up(&vfs_phone_futex);
    194229        free(mpa);
     230       
     231        if ((rc != EOK) && (null_id != -1))
     232                devmap_null_destroy(null_id);
    195233       
    196234        return (int) rc;

  • uspace/lib/libc/include/async.h

    r393bef1 rd42976c  
    277277extern int async_share_out_receive(ipc_callid_t *, size_t *, int *);
    278278extern int async_share_out_finalize(ipc_callid_t, void *);
     279
     280/*
     281 * User-friendly wrappers for async_data_read_forward_fast().
     282 */
     283#define async_data_read_forward_0_0(phoneid, method, answer) \
     284        async_data_read_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL)
     285#define async_data_read_forward_0_1(phoneid, method, answer) \
     286        async_data_read_forward_fast((phoneid), (method), 0, 0, 0, 0, (answer))
     287#define async_data_read_forward_1_0(phoneid, method, arg1, answer) \
     288        async_data_read_forward_fast((phoneid), (method), (arg1), 0, 0, 0, NULL)
     289#define async_data_read_forward_1_1(phoneid, method, arg1, answer) \
     290        async_data_read_forward_fast((phoneid), (method), (arg1), 0, 0, 0, (answer))
     291#define async_data_read_forward_2_0(phoneid, method, arg1, arg2, answer) \
     292        async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, NULL)
     293#define async_data_read_forward_2_1(phoneid, method, arg1, arg2, answer) \
     294        async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, \
     295            (answer))
     296#define async_data_read_forward_3_0(phoneid, method, arg1, arg2, arg3, answer) \
     297        async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, \
     298            NULL)
     299#define async_data_read_forward_3_1(phoneid, method, arg1, arg2, arg3, answer) \
     300        async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, \
     301            (answer))
     302#define async_data_read_forward_4_0(phoneid, method, arg1, arg2, arg3, arg4, answer) \
     303        async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \
     304            (arg4), NULL)
     305#define async_data_read_forward_4_1(phoneid, method, arg1, arg2, arg3, arg4, answer) \
     306        async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \
     307            (arg4), (answer))
     308
    279309extern int async_data_read_start(int, void *, size_t);
    280310extern int async_data_read_receive(ipc_callid_t *, size_t *);
    281311extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
     312
     313extern int async_data_read_forward_fast(int, ipcarg_t, ipcarg_t, ipcarg_t,
     314    ipcarg_t, ipcarg_t, ipc_call_t *);
     315
     316/*
     317 * User-friendly wrappers for async_data_write_forward_fast().
     318 */
     319#define async_data_write_forward_0_0(phoneid, method, answer) \
     320        async_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL)
     321#define async_data_write_forward_0_1(phoneid, method, answer) \
     322        async_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, (answer))
     323#define async_data_write_forward_1_0(phoneid, method, arg1, answer) \
     324        async_data_write_forward_fast((phoneid), (method), (arg1), 0, 0, 0, NULL)
     325#define async_data_write_forward_1_1(phoneid, method, arg1, answer) \
     326        async_data_write_forward_fast((phoneid), (method), (arg1), 0, 0, 0, \
     327            (answer))
     328#define async_data_write_forward_2_0(phoneid, method, arg1, arg2, answer) \
     329        async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, \
     330            NULL)
     331#define async_data_write_forward_2_1(phoneid, method, arg1, arg2, answer) \
     332        async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, \
     333            (answer))
     334#define async_data_write_forward_3_0(phoneid, method, arg1, arg2, arg3, answer) \
     335        async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \
     336            0, NULL)
     337#define async_data_write_forward_3_1(phoneid, method, arg1, arg2, arg3, answer) \
     338        async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \
     339            0, (answer))
     340#define async_data_write_forward_4_0(phoneid, method, arg1, arg2, arg3, arg4, answer) \
     341        async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \
     342            (arg4), NULL)
     343#define async_data_write_forward_4_1(phoneid, method, arg1, arg2, arg3, arg4, answer) \
     344        async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \
     345            (arg4), (answer))
     346
    282347extern int async_data_write_start(int, const void *, size_t);
    283348extern int async_data_write_receive(ipc_callid_t *, size_t *);
    284349extern int async_data_write_finalize(ipc_callid_t, void *, size_t);
    285350
    286 extern int async_data_blob_receive(char **, const size_t, size_t *);
    287 extern int async_data_string_receive(char **, const size_t);
     351extern int async_data_write_accept(void **, const bool, const size_t,
     352    const size_t, const size_t, size_t *);
     353extern void async_data_write_void(const int);
     354
     355extern int async_data_write_forward_fast(int, ipcarg_t, ipcarg_t, ipcarg_t,
     356    ipcarg_t, ipcarg_t, ipc_call_t *);
    288357
    289358#endif

  • uspace/lib/libc/include/fibril.h

    r393bef1 rd42976c  
    4040#include <libarch/tls.h>
    4141
    42 #ifndef context_set
    43 #define context_set(c, _pc, stack, size, ptls) \
     42#define context_set_generic(c, _pc, stack, size, ptls) \
    4443        (c)->pc = (sysarg_t) (_pc); \
    4544        (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
    4645        (c)->tls = (sysarg_t) (ptls);
    47 #endif /* context_set */
    4846
    49 #define FIBRIL_SERIALIZED       1
    50 #define FIBRIL_WRITER           2
     47#define FIBRIL_SERIALIZED  1
     48#define FIBRIL_WRITER      2
    5149
    5250typedef enum {
    … …  
    5957typedef sysarg_t fid_t;
    6058
    61 struct fibril {
     59typedef struct fibril {
    6260        link_t link;
    6361        context_t ctx;
    … …  
    7068        int retval;
    7169        int flags;
    72 };
    73 typedef struct fibril fibril_t;
     70} fibril_t;
    7471
    7572/** Fibril-local variable specifier */
    7673#define fibril_local __thread
    7774
    78 extern int context_save(context_t *c) __attribute__ ((returns_twice));
    79 extern void context_restore(context_t *c) __attribute__ ((noreturn));
     75extern int context_save(context_t *ctx) __attribute__((returns_twice));
     76extern void context_restore(context_t *ctx) __attribute__((noreturn));
    8077
    8178extern fid_t fibril_create(int (*func)(void *), void *arg);
    … …  
    9087extern void fibril_dec_sercount(void);
    9188
    92 static inline int fibril_yield(void) {
     89static inline int fibril_yield(void)
     90{
    9391        return fibril_switch(FIBRIL_PREEMPT);
    9492}

  • uspace/lib/libc/include/ipc/clipboard.h

    r393bef1 rd42976c  
    4646typedef enum {
    4747        CLIPBOARD_TAG_NONE,
    48         CLIPBOARD_TAG_BLOB
     48        CLIPBOARD_TAG_DATA
    4949} clipboard_tag_t;
    5050

  • uspace/lib/libfs/libfs.c

    r393bef1 rd42976c  
    161161        /* Accept the phone */
    162162        callid = async_get_call(&call);
    163         int mountee_phone = (int)IPC_GET_ARG1(call);
     163        int mountee_phone = (int) IPC_GET_ARG1(call);
    164164        if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) ||
    165165            (mountee_phone < 0)) {
    … …  
    172172        ipc_answer_0(callid, EOK);
    173173       
    174         res = async_data_write_receive(&callid, NULL);
    175         if (!res) {
    176                 ipc_hangup(mountee_phone);
    177                 ipc_answer_0(callid, EINVAL);
    178                 ipc_answer_0(rid, EINVAL);
    179                 return;
    180         }
    181        
    182174        fs_node_t *fn;
    183175        res = ops->node_get(&fn, mp_dev_handle, mp_fs_index);
    184176        if ((res != EOK) || (!fn)) {
    185177                ipc_hangup(mountee_phone);
    186                 ipc_answer_0(callid, combine_rc(res, ENOENT));
     178                async_data_write_void(combine_rc(res, ENOENT));
    187179                ipc_answer_0(rid, combine_rc(res, ENOENT));
    188180                return;
    … …  
    192184                ipc_hangup(mountee_phone);
    193185                (void) ops->node_put(fn);
    194                 ipc_answer_0(callid, EBUSY);
     186                async_data_write_void(EBUSY);
    195187                ipc_answer_0(rid, EBUSY);
    196188                return;
    … …  
    201193                ipc_hangup(mountee_phone);
    202194                (void) ops->node_put(fn);
    203                 ipc_answer_0(callid, rc);
     195                async_data_write_void(rc);
    204196                ipc_answer_0(rid, rc);
    205197                return;
    … …  
    207199       
    208200        ipc_call_t answer;
    209         aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle,
    210             &answer);
    211         ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    212         async_wait_for(msg, &rc);
     201        rc = async_data_write_forward_1_1(mountee_phone, VFS_OUT_MOUNTED,
     202            mr_dev_handle, &answer);
    213203       
    214204        if (rc == EOK) {

  • uspace/srv/clip/clip.c

    r393bef1 rd42976c  
    6464                ipc_answer_0(rid, EOK);
    6565                break;
    66         case CLIPBOARD_TAG_BLOB:
    67                 rc = async_data_blob_receive(&data, 0, &size);
     66        case CLIPBOARD_TAG_DATA:
     67                rc = async_data_write_accept((void **) &data, false, 0, 0, 0, &size);
    6868                if (rc != EOK) {
    6969                        ipc_answer_0(rid, rc);
    … …  
    7878                clip_data = data;
    7979                clip_size = size;
    80                 clip_tag = CLIPBOARD_TAG_BLOB;
     80                clip_tag = CLIPBOARD_TAG_DATA;
    8181               
    8282                fibril_mutex_unlock(&clip_mtx);
    … …  
    9797        /* Check for clipboard data tag compatibility */
    9898        switch (IPC_GET_ARG1(*request)) {
    99         case CLIPBOARD_TAG_BLOB:
     99        case CLIPBOARD_TAG_DATA:
    100100                if (!async_data_read_receive(&callid, &size)) {
    101101                        ipc_answer_0(callid, EINVAL);
    … …  
    104104                }
    105105               
    106                 if (clip_tag != CLIPBOARD_TAG_BLOB) {
    107                         /* So far we only understand BLOB */
     106                if (clip_tag != CLIPBOARD_TAG_DATA) {
     107                        /* So far we only understand binary data */
    108108                        ipc_answer_0(callid, EOVERFLOW);
    109109                        ipc_answer_0(rid, EOVERFLOW);

  • uspace/srv/devmap/devmap.c

    r393bef1 rd42976c  
    396396         * Get driver name
    397397         */
    398         int rc = async_data_string_receive(&driver->name, DEVMAP_NAME_MAXLEN);
     398        int rc = async_data_write_accept((void **) &driver->name, true, 0,
     399            DEVMAP_NAME_MAXLEN, 0, NULL);
    399400        if (rc != EOK) {
    400401                free(driver);
    … …  
    510511        /* Get fqdn */
    511512        char *fqdn;
    512         int rc = async_data_string_receive(&fqdn, DEVMAP_NAME_MAXLEN);
     513        int rc = async_data_write_accept((void **) &fqdn, true, 0,
     514            DEVMAP_NAME_MAXLEN, 0, NULL);
    513515        if (rc != EOK) {
    514516                free(device);
    … …  
    622624       
    623625        /* Get fqdn */
    624         int rc = async_data_string_receive(&fqdn, DEVMAP_NAME_MAXLEN);
     626        int rc = async_data_write_accept((void **) &fqdn, true, 0,
     627            DEVMAP_NAME_MAXLEN, 0, NULL);
    625628        if (rc != EOK) {
    626629                ipc_answer_0(iid, rc);
    … …  
    683686       
    684687        /* Get device name */
    685         int rc = async_data_string_receive(&name, DEVMAP_NAME_MAXLEN);
     688        int rc = async_data_write_accept((void **) &name, true, 0,
     689            DEVMAP_NAME_MAXLEN, 0, NULL);
    686690        if (rc != EOK) {
    687691                ipc_answer_0(iid, rc);

  • uspace/srv/fs/devfs/devfs_ops.c

    r393bef1 rd42976c  
    419419       
    420420        /* Accept the mount options */
    421         ipcarg_t retval = async_data_string_receive(&opts, 0);
     421        ipcarg_t retval = async_data_write_accept((void **) &opts, true, 0, 0,
     422            0, NULL);
    422423        if (retval != EOK) {
    423424                ipc_answer_0(rid, retval);

  • uspace/srv/fs/fat/fat_ops.c

    r393bef1 rd42976c  
    974974        uint16_t bps;
    975975        uint16_t rde;
    976         int rc;
    977 
    978         /* accept the mount options */
    979         ipc_callid_t callid;
    980         size_t size;
    981         if (!async_data_write_receive(&callid, &size)) {
    982                 ipc_answer_0(callid, EINVAL);
    983                 ipc_answer_0(rid, EINVAL);
    984                 return;
    985         }
    986         char *opts = malloc(size + 1);
    987         if (!opts) {
    988                 ipc_answer_0(callid, ENOMEM);
    989                 ipc_answer_0(rid, ENOMEM);
    990                 return;
    991         }
    992         ipcarg_t retval = async_data_write_finalize(callid, opts, size);
    993         if (retval != EOK) {
    994                 ipc_answer_0(rid, retval);
    995                 free(opts);
    996                 return;
    997         }
    998         opts[size] = '\0';
     976       
     977        /* Accept the mount options */
     978        char *opts;
     979        int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
     980       
     981        if (rc != EOK) {
     982                ipc_answer_0(rid, rc);
     983                return;
     984        }
    999985
    1000986        /* Check for option enabling write through. */

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r393bef1 rd42976c  
    443443        fs_node_t *rootfn;
    444444        int rc;
    445 
    446         /* accept the mount options */
    447         ipc_callid_t callid;
    448         size_t size;
    449         if (!async_data_write_receive(&callid, &size)) {
    450                 ipc_answer_0(callid, EINVAL);
    451                 ipc_answer_0(rid, EINVAL);
    452                 return;
    453         }
    454         char *opts = malloc(size + 1);
    455         if (!opts) {
    456                 ipc_answer_0(callid, ENOMEM);
    457                 ipc_answer_0(rid, ENOMEM);
    458                 return;
    459         }
    460         ipcarg_t retval = async_data_write_finalize(callid, opts, size);
    461         if (retval != EOK) {
    462                 ipc_answer_0(rid, retval);
    463                 free(opts);
    464                 return;
    465         }
    466         opts[size] = '\0';
    467 
    468         /*
    469          * Check if this device is not already mounted.
    470          */
     445       
     446        /* Accept the mount options. */
     447        char *opts;
     448        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
     449        if (rc != EOK) {
     450                ipc_answer_0(rid, rc);
     451                return;
     452        }
     453
     454        /* Check if this device is not already mounted. */
    471455        rc = tmpfs_root_get(&rootfn, dev_handle);
    472456        if ((rc == EOK) && (rootfn)) {

  • uspace/srv/hid/console/console.c

    r393bef1 rd42976c  
    475475static void cons_write(console_t *cons, ipc_callid_t rid, ipc_call_t *request)
    476476{
    477         ipc_callid_t callid;
     477        void *buf;
    478478        size_t size;
    479         if (!async_data_write_receive(&callid, &size)) {
    480                 ipc_answer_0(callid, EINVAL);
    481                 ipc_answer_0(rid, EINVAL);
     479        int rc = async_data_write_accept(&buf, false, 0, 0, 0, &size);
     480       
     481        if (rc != EOK) {
     482                ipc_answer_0(rid, rc);
    482483                return;
    483484        }
    484        
    485         char *buf = (char *) malloc(size);
    486         if (buf == NULL) {
    487                 ipc_answer_0(callid, ENOMEM);
    488                 ipc_answer_0(rid, ENOMEM);
    489                 return;
    490         }
    491        
    492         (void) async_data_write_finalize(callid, buf, size);
    493485       
    494486        async_serialize_start();

  • uspace/srv/loader/main.c

    r393bef1 rd42976c  
    125125static void ldr_set_cwd(ipc_callid_t rid, ipc_call_t *request)
    126126{
    127         ipc_callid_t callid;
    128         size_t len;
    129        
    130         if (!async_data_write_receive(&callid, &len)) {
    131                 ipc_answer_0(callid, EINVAL);
    132                 ipc_answer_0(rid, EINVAL);
    133                 return;
    134         }
    135        
    136         cwd = malloc(len + 1);
    137         if (!cwd) {
    138                 ipc_answer_0(callid, ENOMEM);
    139                 ipc_answer_0(rid, ENOMEM);
    140                 return;
    141         }
    142        
    143         async_data_write_finalize(callid, cwd, len);
    144         cwd[len] = '\0';
    145        
    146         ipc_answer_0(rid, EOK);
     127        char *buf;
     128        int rc = async_data_write_accept((void **) &buf, true, 0, 0, 0, NULL);
     129       
     130        if (rc == EOK) {
     131                if (cwd != NULL)
     132                        free(cwd);
     133               
     134                cwd = buf;
     135        }
     136       
     137        ipc_answer_0(rid, rc);
    147138}
    148139
    … …  
    154145static void ldr_set_pathname(ipc_callid_t rid, ipc_call_t *request)
    155146{
    156         ipc_callid_t callid;
    157         size_t len;
    158         char *name_buf;
    159        
    160         if (!async_data_write_receive(&callid, &len)) {
    161                 ipc_answer_0(callid, EINVAL);
    162                 ipc_answer_0(rid, EINVAL);
    163                 return;
    164         }
    165        
    166         name_buf = malloc(len + 1);
    167         if (!name_buf) {
    168                 ipc_answer_0(callid, ENOMEM);
    169                 ipc_answer_0(rid, ENOMEM);
    170                 return;
    171         }
    172        
    173         async_data_write_finalize(callid, name_buf, len);
    174         ipc_answer_0(rid, EOK);
    175        
    176         if (pathname != NULL) {
    177                 free(pathname);
    178                 pathname = NULL;
    179         }
    180        
    181         name_buf[len] = '\0';
    182         pathname = name_buf;
     147        char *buf;
     148        int rc = async_data_write_accept((void **) &buf, true, 0, 0, 0, NULL);
     149       
     150        if (rc == EOK) {
     151                if (pathname != NULL)
     152                        free(pathname);
     153               
     154                pathname = buf;
     155        }
     156       
     157        ipc_answer_0(rid, rc);
    183158}
    184159
    … …  
    190165static void ldr_set_args(ipc_callid_t rid, ipc_call_t *request)
    191166{
    192         ipc_callid_t callid;
    193         size_t buf_size, arg_size;
    194         char *p;
    195         int n;
    196        
    197         if (!async_data_write_receive(&callid, &buf_size)) {
    198                 ipc_answer_0(callid, EINVAL);
    199                 ipc_answer_0(rid, EINVAL);
    200                 return;
    201         }
    202        
    203         if (arg_buf != NULL) {
    204                 free(arg_buf);
    205                 arg_buf = NULL;
    206         }
    207        
    208         if (argv != NULL) {
    209                 free(argv);
    210                 argv = NULL;
    211         }
    212        
    213         arg_buf = malloc(buf_size + 1);
    214         if (!arg_buf) {
    215                 ipc_answer_0(callid, ENOMEM);
    216                 ipc_answer_0(rid, ENOMEM);
    217                 return;
    218         }
    219        
    220         async_data_write_finalize(callid, arg_buf, buf_size);
    221        
    222         arg_buf[buf_size] = '\0';
    223        
    224         /*
    225          * Count number of arguments
    226          */
    227         p = arg_buf;
    228         n = 0;
    229         while (p < arg_buf + buf_size) {
    230                 arg_size = str_size(p);
    231                 p = p + arg_size + 1;
    232                 ++n;
    233         }
    234        
    235         /* Allocate argv */
    236         argv = malloc((n + 1) * sizeof(char *));
    237        
    238         if (argv == NULL) {
    239                 free(arg_buf);
    240                 ipc_answer_0(rid, ENOMEM);
    241                 return;
    242         }
    243 
    244         /*
    245          * Fill argv with argument pointers
    246          */
    247         p = arg_buf;
    248         n = 0;
    249         while (p < arg_buf + buf_size) {
    250                 argv[n] = p;
    251                
    252                 arg_size = str_size(p);
    253                 p = p + arg_size + 1;
    254                 ++n;
    255         }
    256        
    257         argc = n;
    258         argv[n] = NULL;
    259 
    260         ipc_answer_0(rid, EOK);
     167        char *buf;
     168        size_t buf_size;
     169        int rc = async_data_write_accept((void **) &buf, true, 0, 0, 0, &buf_size);
     170       
     171        if (rc == EOK) {
     172                /*
     173                 * Count number of arguments
     174                 */
     175                char *cur = buf;
     176                int count = 0;
     177               
     178                while (cur < buf + buf_size) {
     179                        size_t arg_size = str_size(cur);
     180                        cur += arg_size + 1;
     181                        count++;
     182                }
     183               
     184                /*
     185                 * Allocate new argv
     186                 */
     187                char **_argv = (char **) malloc((count + 1) * sizeof(char *));
     188                if (_argv == NULL) {
     189                        free(buf);
     190                        ipc_answer_0(rid, ENOMEM);
     191                        return;
     192                }
     193               
     194                /*
     195                 * Fill the new argv with argument pointers
     196                 */
     197                cur = buf;
     198                count = 0;
     199                while (cur < buf + buf_size) {
     200                        _argv[count] = cur;
     201                       
     202                        size_t arg_size = str_size(cur);
     203                        cur += arg_size + 1;
     204                        count++;
     205                }
     206                _argv[count] = NULL;
     207               
     208                /*
     209                 * Copy temporary data to global variables
     210                 */
     211                if (arg_buf != NULL)
     212                        free(arg_buf);
     213               
     214                if (argv != NULL)
     215                        free(argv);
     216               
     217                argc = count;
     218                arg_buf = buf;
     219                argv = _argv;
     220        }
     221       
     222        ipc_answer_0(rid, rc);
    261223}
    262224
    … …  
    268230static void ldr_set_files(ipc_callid_t rid, ipc_call_t *request)
    269231{
    270         ipc_callid_t callid;
     232        fdi_node_t *buf;
    271233        size_t buf_size;
    272         if (!async_data_write_receive(&callid, &buf_size)) {
    273                 ipc_answer_0(callid, EINVAL);
    274                 ipc_answer_0(rid, EINVAL);
    275                 return;
    276         }
    277        
    278         if ((buf_size % sizeof(fdi_node_t)) != 0) {
    279                 ipc_answer_0(callid, EINVAL);
    280                 ipc_answer_0(rid, EINVAL);
    281                 return;
    282         }
    283        
    284         if (fil_buf != NULL) {
    285                 free(fil_buf);
    286                 fil_buf = NULL;
    287         }
    288        
    289         if (filv != NULL) {
    290                 free(filv);
    291                 filv = NULL;
    292         }
    293        
    294         fil_buf = malloc(buf_size);
    295         if (!fil_buf) {
    296                 ipc_answer_0(callid, ENOMEM);
    297                 ipc_answer_0(rid, ENOMEM);
    298                 return;
    299         }
    300        
    301         async_data_write_finalize(callid, fil_buf, buf_size);
    302        
    303         int count = buf_size / sizeof(fdi_node_t);
    304        
    305         /* Allocate filvv */
    306         filv = malloc((count + 1) * sizeof(fdi_node_t *));
    307        
    308         if (filv == NULL) {
    309                 free(fil_buf);
    310                 ipc_answer_0(rid, ENOMEM);
    311                 return;
    312         }
    313        
    314         /*
    315          * Fill filv with argument pointers
    316          */
    317         int i;
    318         for (i = 0; i < count; i++)
    319                 filv[i] = &fil_buf[i];
    320        
    321         filc = count;
    322         filv[count] = NULL;
     234        int rc = async_data_write_accept((void **) &buf, false, 0, 0,
     235            sizeof(fdi_node_t), &buf_size);
     236       
     237        if (rc == EOK) {
     238                int count = buf_size / sizeof(fdi_node_t);
     239               
     240                /*
     241                 * Allocate new filv
     242                 */
     243                fdi_node_t **_filv = (fdi_node_t *) malloc((count + 1) * sizeof(fdi_node_t *));
     244                if (_filv == NULL) {
     245                        free(buf);
     246                        ipc_answer_0(rid, ENOMEM);
     247                        return;
     248                }
     249               
     250                /*
     251                 * Fill the new filv with argument pointers
     252                 */
     253                int i;
     254                for (i = 0; i < count; i++)
     255                        _filv[i] = &buf[i];
     256               
     257                _filv[count] = NULL;
     258               
     259                /*
     260                 * Copy temporary data to global variables
     261                 */
     262                if (fil_buf != NULL)
     263                        free(fil_buf);
     264               
     265                if (filv != NULL)
     266                        free(filv);
     267               
     268                filc = count;
     269                fil_buf = buf;
     270                filv = _filv;
     271        }
    323272       
    324273        ipc_answer_0(rid, EOK);

  • uspace/srv/vfs/vfs_ops.c

    r393bef1 rd42976c  
    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);

  • uspace/srv/vfs/vfs_register.c

    r393bef1 rd42976c  
    110110void vfs_register(ipc_callid_t rid, ipc_call_t *request)
    111111{
    112         ipc_callid_t callid;
    113         ipc_call_t call;
    114         int rc;
    115         size_t size;
    116 
    117112        dprintf("Processing VFS_REGISTER request received from %p.\n",
    118113            request->in_phone_hash);
    119 
    120         /*
    121          * The first call has to be IPC_M_DATA_SEND in which we receive the
    122          * VFS info structure from the client FS.
    123          */
    124         if (!async_data_write_receive(&callid, &size)) {
    125                 /*
    126                  * The client doesn't obey the same protocol as we do.
    127                  */
    128                 dprintf("Receiving of VFS info failed.\n");
    129                 ipc_answer_0(callid, EINVAL);
    130                 ipc_answer_0(rid, EINVAL);
    131                 return;
    132         }
    133        
    134         dprintf("VFS info received, size = %d\n", size);
    135        
    136         /*
    137          * We know the size of the VFS info structure. See if the client
    138          * understands this easy concept too.
    139          */
    140         if (size != sizeof(vfs_info_t)) {
    141                 /*
    142                  * The client is sending us something, which cannot be
    143                  * the info structure.
    144                  */
    145                 dprintf("Received VFS info has bad size.\n");
    146                 ipc_answer_0(callid, EINVAL);
    147                 ipc_answer_0(rid, EINVAL);
    148                 return;
    149         }
    150 
    151         /*
    152          * Allocate and initialize a buffer for the fs_info structure.
    153          */
    154         fs_info_t *fs_info;
    155         fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
    156         if (!fs_info) {
    157                 dprintf("Could not allocate memory for FS info.\n");
    158                 ipc_answer_0(callid, ENOMEM);
    159                 ipc_answer_0(rid, ENOMEM);
    160                 return;
    161         }
    162         link_initialize(&fs_info->fs_link);
    163         fibril_mutex_initialize(&fs_info->phone_lock);
    164                
    165         rc = async_data_write_finalize(callid, &fs_info->vfs_info, size);
     114       
     115        vfs_info_t *vfs_info;
     116        int rc = async_data_write_accept((void **) &vfs_info, false,
     117            sizeof(vfs_info_t), sizeof(vfs_info_t), 0, NULL);
     118       
    166119        if (rc != EOK) {
    167120                dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
    168121                    rc);
    169                 free(fs_info);
    170                 ipc_answer_0(callid, rc);
    171122                ipc_answer_0(rid, rc);
    172123                return;
    173124        }
    174 
     125       
     126        /*
     127         * Allocate and initialize a buffer for the fs_info structure.
     128         */
     129        fs_info_t *fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
     130        if (!fs_info) {
     131                dprintf("Could not allocate memory for FS info.\n");
     132                ipc_answer_0(rid, ENOMEM);
     133                return;
     134        }
     135       
     136        link_initialize(&fs_info->fs_link);
     137        fibril_mutex_initialize(&fs_info->phone_lock);
     138        fs_info->vfs_info = *vfs_info;
     139        free(vfs_info);
     140       
    175141        dprintf("VFS info delivered.\n");
    176                
     142       
    177143        if (!vfs_info_sane(&fs_info->vfs_info)) {
    178144                free(fs_info);
    179                 ipc_answer_0(callid, EINVAL);
    180145                ipc_answer_0(rid, EINVAL);
    181146                return;
    182147        }
    183                
     148       
    184149        fibril_mutex_lock(&fs_head_lock);
    185 
     150       
    186151        /*
    187152         * Check for duplicit registrations.
    … …  
    194159                fibril_mutex_unlock(&fs_head_lock);
    195160                free(fs_info);
    196                 ipc_answer_0(callid, EEXISTS);
    197161                ipc_answer_0(rid, EEXISTS);
    198162                return;
    199163        }
    200 
     164       
    201165        /*
    202166         * Add fs_info to the list of registered FS's.
    … …  
    210174         * which to forward VFS requests to it.
    211175         */
    212         callid = async_get_call(&call);
     176        ipc_call_t call;
     177        ipc_callid_t callid = async_get_call(&call);
    213178        if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
    214179                dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
    … …  
    222187        fs_info->phone = IPC_GET_ARG5(call);
    223188        ipc_answer_0(callid, EOK);
    224 
     189       
    225190        dprintf("Callback connection to FS created.\n");
    226 
     191       
    227192        /*
    228193         * The client will want us to send him the address space area with PLB.
    229194         */
    230 
     195       
     196        size_t size;
    231197        if (!async_share_in_receive(&callid, &size)) {
    232198                dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
    … …  
    253219                return;
    254220        }
    255 
     221       
    256222        /*
    257223         * Commit to read-only sharing the PLB with the client.
    … …  
    259225        (void) async_share_in_finalize(callid, plb,
    260226            AS_AREA_READ | AS_AREA_CACHEABLE);
    261 
     227       
    262228        dprintf("Sharing PLB.\n");
    263 
     229       
    264230        /*
    265231         * That was it. The FS has been registered.
Note: See TracChangeset for help on using the changeset viewer.