Changes in / [e768aea:8119363] in mainline


Ignore:
Files:
17 added
1 deleted
43 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    re768aea r8119363  
    139139        nic/rtl8169 \
    140140        nic/ar9271 \
     141        nic/virtio-net \
    141142        block/ahci
    142143

  • kernel/generic/include/stdbool.h

    re768aea r8119363  
    4141#define true   1
    4242
    43 #define __bool_true_false_are_defined 1
     43#define __bool_true_false_are_defined  1
    4444
    4545#endif

  • tools/ew.py

    re768aea r8119363  
    146146        return ' -device rtl8139,vlan=0'
    147147
     148def qemu_nic_virtio_options():
     149        return ' -device virtio-net,vlan=0'
     150
    148151def qemu_net_options():
    149152        if is_override('nonet'):
    … …  
    158161                if 'ne2k' in overrides['net'].keys():
    159162                        nic_options += qemu_nic_ne2k_options()
     163                if 'virtio-net' in overrides['net'].keys():
     164                        nic_options += qemu_nic_virtio_options()
    160165        else:
    161166                # Use the default NIC
    … …  
    326331def usage():
    327332        print("%s - emulator wrapper for running HelenOS\n" % os.path.basename(sys.argv[0]))
    328         print("%s [-d] [-h] [-net e1k|rtl8139|ne2k] [-nohdd] [-nokvm] [-nonet] [-nosnd] [-nousb] [-noxhci] [-notablet]\n" %
     333        print("%s [-d] [-h] [-net e1k|rtl8139|ne2k|virtio-net] [-nohdd] [-nokvm] [-nonet] [-nosnd] [-nousb] [-noxhci] [-notablet]\n" %
    329334            os.path.basename(sys.argv[0]))
    330335        print("-d\tDry run: do not run the emulation, just print the command line.")
    … …  
    360365                        elif sys.argv[i] == 'ne2k':
    361366                                overrides['net']['ne2k'] = True
     367                        elif sys.argv[i] == 'virtio-net':
     368                                overrides['net']['virtio-net'] = True
    362369                        else:
    363370                                usage()

  • uspace/Makefile

    re768aea r8119363  
    181181        drv/nic/rtl8169 \
    182182        drv/nic/ar9271 \
     183        drv/nic/virtio-net \
    183184        drv/platform/amdm37x \
    184185        drv/platform/icp \
    … …  
    251252        lib/bithenge \
    252253        lib/posix \
    253         lib/ieee80211
     254        lib/ieee80211 \
     255        lib/virtio
    254256
    255257BASE_BUILDS := $(addsuffix .build,$(BASE_LIBS))

  • uspace/Makefile.common

    re768aea r8119363  
    165165ifneq ($(TEST_SOURCES),)
    166166        TEST_OUTPUTS = $(TEST_BINARY) $(TEST_BINARY).disasm
    167         TEST_CFLAGS = -I$(LIB_PREFIX)/pcut/include -D__helenos__
     167        TEST_CFLAGS = -I$(LIB_PREFIX)/pcut/include -D__helenos__ $(EXTRA_TEST_CFLAGS)
    168168        TEST_BINARY_LIBS = $(LIB_PREFIX)/pcut/libpcut.a
    169169        EXTRA_CLEAN += $(TEST_OUTPUTS) $(TEST_BINARY).map

  • uspace/drv/bus/pci/pciintel/pci.c

    re768aea r8119363  
    738738
    739739                if (pio_enable_resource(&bus->pio_win,
    740                     &hw_resources.resources[0],
    741                     (void **) &bus->conf_space)) {
     740                    &hw_resources.resources[0], (void **) &bus->conf_space,
     741                    NULL, NULL)) {
    742742                        ddf_msg(LVL_ERROR,
    743743                            "Failed to map configuration space.");
    … …  
    759759
    760760                if (pio_enable_resource(&bus->pio_win,
    761                     &hw_resources.resources[0],
    762                     (void **) &bus->conf_addr_reg)) {
     761                    &hw_resources.resources[0], (void **) &bus->conf_addr_reg,
     762                    NULL, NULL)) {
    763763                        ddf_msg(LVL_ERROR,
    764764                            "Failed to enable configuration ports.");
    … …  
    767767                }
    768768                if (pio_enable_resource(&bus->pio_win,
    769                     &hw_resources.resources[1],
    770                     (void **) &bus->conf_data_reg)) {
     769                    &hw_resources.resources[1], (void **) &bus->conf_data_reg,
     770                    NULL, NULL)) {
    771771                        ddf_msg(LVL_ERROR,
    772772                            "Failed to enable configuration ports.");

  • uspace/lib/bithenge/src/helenos/common.h

    re768aea r8119363  
    7373}
    7474
    75 static inline void *memchr(const void *s, int c, size_t n)
    76 {
    77         for (size_t i = 0; i < n; i++)
    78                 if (((char *)s)[i] == c)
    79                         return (void *)(s + i);
    80         return NULL;
    81 }
    82 
    8375static inline errno_t bithenge_parse_int(const char *start, bithenge_int_t *result)
    8476{

  • uspace/lib/c/Makefile

    re768aea r8119363  
    4141EXTRA_OUTPUT = $(LINKER_SCRIPTS)
    4242EXTRA_CLEAN = $(LINKER_SCRIPTS)
     43EXTRA_TEST_CFLAGS = -Wno-deprecated-declarations
    4344LIBRARY = libc
    4445SOVERSION = 0.0
    … …  
    132133        generic/malloc.c \
    133134        generic/stdio/scanf.c \
     135        generic/stdio/sprintf.c \
    134136        generic/stdio/sscanf.c \
    135137        generic/stdio/sstream.c \
     138        generic/stdio/vsprintf.c \
    136139        generic/sysinfo.c \
    137140        generic/ipc.c \
    … …  
    149152        generic/adt/prodcons.c \
    150153        generic/time.c \
     154        generic/tmpfile.c \
    151155        generic/stdio.c \
    152156        generic/stdlib.c \
    … …  
    189193        test/fibril/timer.c \
    190194        test/main.c \
     195        test/mem.c \
    191196        test/io/table.c \
    192197        test/stdio/scanf.c \
    … …  
    194199        test/qsort.c \
    195200        test/sprintf.c \
     201        test/stdio.c \
    196202        test/stdlib.c \
    197203        test/str.c

  • uspace/lib/c/arch/arm32/include/libarch/fibril_context.h

    re768aea r8119363  
    4949        uint32_t r7;
    5050        uint32_t r8;
    51         /* r9*/
     51        /* r9 */
    5252        uint32_t tls;
    5353        uint32_t r10;
    … …  
    5757
    5858#endif
    59 

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

    re768aea r8119363  
    190190        free(msg);
    191191}
    192 
    193192
    194193/** Mutex protecting inactive_exch_list and avail_phone_cv.

  • uspace/lib/c/generic/ddi.c

    re768aea r8119363  
    220220/** Enable PIO for specified HW resource wrt. to the PIO window.
    221221 *
    222  * @param win      PIO window. May be NULL if the resources are known to be
    223  *                 absolute.
    224  * @param res      Resources specifying the I/O range wrt. to the PIO window.
    225  * @param virt     Virtual address for application's PIO operations.
     222 * @param win        PIO window. May be NULL if the resources are known to be
     223 *                   absolute.
     224 * @param res        Resources specifying the I/O range wrt. to the PIO window.
     225 * @param[out] virt  Virtual address for application's PIO operations.
     226 * @param[out] phys  If non-NULL, physical address of the resource
     227 * @param[out] size  If non-NULL, size of the enabled resource.
    226228 *
    227229 * @return EOK on success.
    … …  
    229231 *
    230232 */
    231 errno_t pio_enable_resource(pio_window_t *win, hw_resource_t *res, void **virt)
     233errno_t pio_enable_resource(pio_window_t *win, hw_resource_t *res, void **virt,
     234    uintptr_t *phys, size_t *size)
    232235{
    233236        uintptr_t addr;
    234         size_t size;
     237        size_t sz;
    235238
    236239        switch (res->type) {
    … …  
    242245                        addr += win->io.base;
    243246                }
    244                 size = res->res.io_range.size;
     247                sz = res->res.io_range.size;
    245248                break;
    246249        case MEM_RANGE:
    … …  
    251254                        addr += win->mem.base;
    252255                }
    253                 size = res->res.mem_range.size;
     256                sz = res->res.mem_range.size;
    254257                break;
    255258        default:
    … …  
    257260        }
    258261
    259         return pio_enable((void *) addr, size, virt);
     262        if (phys)
     263                *phys = addr;
     264        if (size)
     265                *size = sz;
     266
     267        return pio_enable((void *) addr, sz, virt);
    260268}
    261269

  • uspace/lib/c/generic/io/printf_core.c

    re768aea r8119363  
    3939#include <stdio.h>
    4040#include <stddef.h>
     41#include <stdlib.h>
    4142#include <io/printf_core.h>
    4243#include <ctype.h>

  • uspace/lib/c/generic/io/snprintf.c

    re768aea r8119363  
    3535#include <stdarg.h>
    3636#include <stdio.h>
    37 #include <io/printf_core.h>
    3837
    3938/** Print formatted to the given buffer with limited size.

  • uspace/lib/c/generic/mem.c

    re768aea r8119363  
    11/*
    22 * Copyright (c) 2005 Martin Decky
    3  * Copyright (c) 2008 Jiri Svoboda
     3 * Copyright (c) 2018 Jiri Svoboda
    44 * All rights reserved.
    55 *
    … …  
    252252}
    253253
     254/** Search memory area.
     255 *
     256 * @param s Memory area
     257 * @param c Character (byte) to search for
     258 * @param n Size of memory area in bytes
     259 *
     260 * @return Pointer to the first occurrence of @a c in the first @a n
     261 *         bytes of @a s or @c NULL if not found.
     262 */
     263void *memchr(const void *s, int c, size_t n)
     264{
     265        uint8_t *u = (uint8_t *) s;
     266        unsigned char uc = (unsigned char) c;
     267        size_t i;
     268
     269        for (i = 0; i < n; i++) {
     270                if (u[i] == uc)
     271                        return (void *) &u[i];
     272        }
     273
     274        return NULL;
     275}
     276
    254277/** @}
    255278 */

  • uspace/lib/c/generic/stdio.c

    re768aea r8119363  
    11/*
    2  * Copyright (c) 2017 Jiri Svoboda
     2 * Copyright (c) 2018 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3434
    3535#include <errno.h>
     36#include <stdbool.h>
    3637#include <stdio.h>
     38#include <str.h>
     39#include <str_error.h>
     40#include <tmpfile.h>
    3741#include <vfs/vfs.h>
     42
     43/** Static buffer for tmpnam function */
     44static char tmpnam_buf[L_tmpnam];
     45
     46/** Get stream position.
     47 *
     48 * @param stream Stream
     49 * @param pos Place to store position
     50 *
     51 * @return Zero on success, non-zero on failure
     52 */
     53int fgetpos(FILE *stream, fpos_t *pos)
     54{
     55        off64_t p;
     56
     57        p = ftell64(stream);
     58        if (p < 0)
     59                return -1;
     60
     61        pos->pos = p;
     62        return 0;
     63}
     64
     65/** Get stream position.
     66 *
     67 * @param stream Stream
     68 * @param pos Position
     69 *
     70 * @return Zero on sucess, non-zero on failure
     71 */
     72int fsetpos(FILE *stream, const fpos_t *pos)
     73{
     74        int rc;
     75
     76        rc = fseek64(stream, pos->pos, SEEK_SET);
     77        if (rc < 0)
     78                return -1;
     79
     80        return 0;
     81}
    3882
    3983/** Rename file or directory (C standard) */
    … …  
    4488        rc = vfs_rename_path(old_path, new_path);
    4589        if (rc != EOK) {
     90                /*
     91                 * Note that ISO C leaves the value of errno undefined,
     92                 * whereas according to UN*X standards, it is set.
     93                 */
    4694                errno = rc;
    4795                return -1;
    … …  
    58106        rc = vfs_unlink_path(path);
    59107        if (rc != EOK) {
     108                /*
     109                 * Note that ISO C leaves the value of errno undefined,
     110                 * whereas according to UN*X standards, it is set.
     111                 */
    60112                errno = rc;
    61113                return -1;
    … …  
    65117}
    66118
     119/** Create a temporary file.
     120 *
     121 * @return Open stream descriptor or @c NULL on error. In that case
     122 *         errno is set (UN*X). Note that ISO C leaves the value of errno
     123 *         undefined.
     124 */
     125FILE *tmpfile(void)
     126{
     127        int file;
     128        FILE *stream;
     129
     130        file = __tmpfile();
     131        if (file < 0) {
     132                printf("file is < 0\n");
     133                errno = EEXIST;
     134                return NULL;
     135        }
     136
     137        stream = fdopen(file, "w+");
     138        if (stream == NULL) {
     139                printf("stream = NULL\n");
     140                vfs_put(file);
     141                errno = EACCES;
     142                return NULL;
     143        }
     144
     145        return stream;
     146}
     147
     148/** Create name for a temporary file.
     149 *
     150 * @param s Pointer to array of at least L_tmpnam bytes or @c NULL.
     151 * @return The pointer @a s or pointer to internal static buffer on success,
     152 *         @c NULL on error.
     153 */
     154char *tmpnam(char *s)
     155{
     156        char *p;
     157
     158        p = (s != NULL) ? s : tmpnam_buf;
     159        return __tmpnam(p);
     160}
     161
     162/** Print error message and string representation of @c errno.
     163 *
     164 * @param s Error message
     165 */
     166void perror(const char *s)
     167{
     168        if (s != NULL && *s != '\0')
     169                fprintf(stderr, "%s: %s\n", s, str_error(errno));
     170        else
     171                fprintf(stderr, "%s\n", str_error(errno));
     172}
     173
     174
    67175/** @}
    68176 */

  • uspace/lib/c/generic/stdlib.c

    re768aea r8119363  
    195195}
    196196
     197/** Compute the absolute value of an integer.
     198 *
     199 * If the result cannot be represented, the behavior is undefined.
     200 *
     201 * @param j Integer
     202 * @return The absolute value of @a j
     203 */
     204int abs(int j)
     205{
     206        int aj;
     207
     208        if (j < 0) {
     209                aj = -j;
     210                assert(aj >= 0);
     211        } else {
     212                aj = j;
     213        }
     214
     215        return aj;
     216}
     217
     218/** Compute the absolute value of a long integer.
     219 *
     220 * If the result cannot be represented, the behavior is undefined.
     221 *
     222 * @param j Long integer
     223 * @return The absolute value of @a j
     224 */
     225long labs(long j)
     226{
     227        long aj;
     228
     229        if (j < 0) {
     230                aj = -j;
     231                assert(aj >= 0);
     232        } else {
     233                aj = j;
     234        }
     235
     236        return aj;
     237}
     238
     239/** Compute the absolute value of a long long integer.
     240 *
     241 * If the result cannot be represented, the behavior is undefined.
     242 *
     243 * @param j Long long integer
     244 * @return The absolute value of @a j
     245 */
     246long long llabs(long long j)
     247{
     248        long long aj;
     249
     250        if (j < 0) {
     251                aj = -j;
     252                assert(aj >= 0);
     253        } else {
     254                aj = j;
     255        }
     256
     257        return aj;
     258}
     259
    197260/** Compute quotient and remainder of int division.
    198261 *

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

    re768aea r8119363  
    285285{
    286286        size_t abs_size;
    287         char *abs = vfs_absolutize(path, &abs_size);
    288         if (!abs)
     287        char *abs_path = vfs_absolutize(path, &abs_size);
     288        if (abs_path == NULL)
    289289                return ENOMEM;
    290290
    291291        int fd;
    292         errno_t rc = vfs_lookup(abs, WALK_DIRECTORY, &fd);
     292        errno_t rc = vfs_lookup(abs_path, WALK_DIRECTORY, &fd);
    293293        if (rc != EOK) {
    294                 free(abs);
     294                free(abs_path);
    295295                return rc;
    296296        }
    … …  
    305305
    306306        cwd_fd = fd;
    307         cwd_path = abs;
     307        cwd_path = abs_path;
    308308        cwd_size = abs_size;
    309309

  • uspace/lib/c/include/adt/hash_table.h

    re768aea r8119363  
    102102    void *);
    103103
    104 
    105104#endif
    106105

  • uspace/lib/c/include/cc.h

    re768aea r8119363  
    4444#endif
    4545
    46 
    4746#endif
    4847

  • uspace/lib/c/include/ddi.h

    re768aea r8119363  
    4040#include <stdint.h>
    4141#include <sys/time.h>
     42#include <byteorder.h>
    4243#include <abi/ddi/irq.h>
    4344#include <device/hw_res.h>
    … …  
    6465
    6566extern errno_t pio_enable_range(addr_range_t *, void **);
    66 extern errno_t pio_enable_resource(pio_window_t *, hw_resource_t *, void **);
     67extern errno_t pio_enable_resource(pio_window_t *, hw_resource_t *, void **,
     68    uintptr_t *, size_t *);
    6769extern errno_t pio_enable(void *, size_t, void **);
    6870extern errno_t pio_disable(void *, size_t);
    … …  
    8587extern uint64_t pio_read_64(const ioport64_t *);
    8688
     89static inline void pio_write_le16(ioport16_t *reg, uint16_t val)
     90{
     91        pio_write_16(reg, host2uint16_t_le(val));
     92}
     93static inline void pio_write_be16(ioport16_t *reg, uint16_t val)
     94{
     95        pio_write_16(reg, host2uint16_t_be(val));
     96}
     97static inline void pio_write_le32(ioport32_t *reg, uint32_t val)
     98{
     99        pio_write_32(reg, host2uint32_t_le(val));
     100}
     101static inline void pio_write_be32(ioport32_t *reg, uint32_t val)
     102{
     103        pio_write_32(reg, host2uint32_t_be(val));
     104}
     105static inline void pio_write_le64(ioport64_t *reg, uint64_t val)
     106{
     107        pio_write_64(reg, host2uint64_t_le(val));
     108}
     109static inline void pio_write_be64(ioport64_t *reg, uint64_t val)
     110{
     111        pio_write_64(reg, host2uint64_t_be(val));
     112}
     113
     114static inline uint16_t pio_read_le16(const ioport16_t *reg)
     115{
     116        return uint16_t_le2host(pio_read_16(reg));
     117}
     118static inline uint16_t pio_read_be16(const ioport16_t *reg)
     119{
     120        return uint16_t_be2host(pio_read_16(reg));
     121}
     122static inline uint32_t pio_read_le32(const ioport32_t *reg)
     123{
     124        return uint32_t_le2host(pio_read_32(reg));
     125}
     126static inline uint32_t pio_read_be32(const ioport32_t *reg)
     127{
     128        return uint32_t_be2host(pio_read_32(reg));
     129}
     130static inline uint64_t pio_read_le64(const ioport64_t *reg)
     131{
     132        return uint64_t_le2host(pio_read_64(reg));
     133}
     134static inline uint64_t pio_read_be64(const ioport64_t *reg)
     135{
     136        return uint64_t_be2host(pio_read_64(reg));
     137}
     138
    87139static inline uint8_t pio_change_8(ioport8_t *reg, uint8_t val, uint8_t mask,
    88140    useconds_t delay)

  • uspace/lib/c/include/fibril_synch.h

    re768aea r8119363  
    6767typedef struct {
    6868        fibril_owner_info_t oi;  /**< Keep this the first thing. */
    69         unsigned writers;
    70         unsigned readers;
     69        unsigned int writers;
     70        unsigned int readers;
    7171        list_t waiters;
    7272} fibril_rwlock_t;
    … …  
    145145/** A counting semaphore for fibrils. */
    146146typedef struct {
    147         long count;
     147        long int count;
    148148        list_t waiters;
    149149} fibril_semaphore_t;

  • uspace/lib/c/include/ipc/common.h

    re768aea r8119363  
    5050        task_id_t in_task_id;
    5151        sysarg_t in_phone_hash;
    52         unsigned flags;
     52        unsigned int flags;
    5353        struct async_call *label;
    5454        cap_call_handle_t cap_handle;

  • uspace/lib/c/include/macros.h

    re768aea r8119363  
    3838#define min(a, b)  ((a) < (b) ? (a) : (b))
    3939#define max(a, b)  ((a) > (b) ? (a) : (b))
    40 #define abs(a)     ((a) >= 0 ? (a) : -(a))
     40#define mabs(a)    ((a) >= 0 ? (a) : -(a))
    4141
    4242#define ARRAY_SIZE(array)   (sizeof(array) / sizeof(array[0]))

  • uspace/lib/c/include/mem.h

    re768aea r8119363  
    11/*
    22 * Copyright (c) 2005 Martin Decky
     3 * Copyright (c) 2018 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4950extern int memcmp(const void *, const void *, size_t)
    5051    __attribute__((nonnull(1, 2)));
     52extern void *memchr(const void *, int, size_t)
     53    __attribute__((nonnull(1)));
    5154
    5255#endif

  • uspace/lib/c/include/stdbool.h

    re768aea r8119363  
    4141#define true   1
    4242
    43 #define __bool_true_false_are_defined 1
     43#define __bool_true_false_are_defined  1
    4444
    4545#endif

  • uspace/lib/c/include/stdio.h

    re768aea r8119363  
    11/*
    22 * Copyright (c) 2005 Martin Decky
     3 * Copyright (c) 2018 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    3637#define LIBC_STDIO_H_
    3738
     39#include <offset.h>
    3840#include <stdarg.h>
    3941#include <io/verify.h>
     42#include <_bits/NULL.h>
    4043#include <_bits/size_t.h>
    4144#include <_bits/wchar_t.h>
    4245#include <_bits/wint_t.h>
    4346
    44 #define EOF  (-1)
    45 
    46 #ifndef SEEK_SET
    47 #define SEEK_SET  0
    48 #endif
    49 
    50 #ifndef SEEK_CUR
    51 #define SEEK_CUR  1
    52 #endif
    53 
    54 #ifndef SEEK_END
    55 #define SEEK_END  2
    56 #endif
    57 
    58 /** Default size for stream I/O buffers */
    59 #define BUFSIZ  4096
    60 
    61 /** Recommended size of fixed-size array for holding file names. */
    62 #define FILENAME_MAX 4096
    63 
    6447/** Forward declaration */
    6548struct _IO_FILE;
    6649typedef struct _IO_FILE FILE;
     50
     51/** File position */
     52typedef struct {
     53        off64_t pos;
     54} fpos_t;
     55
     56#ifndef _HELENOS_SOURCE
     57#define _IONBF 0
     58#define _IOLBF 1
     59#define _IOFBF 2
     60#endif
     61
     62/** Default size for stream I/O buffers */
     63#define BUFSIZ  4096
     64
     65#define EOF  (-1)
     66
     67/** Max number of files that is guaranteed to be able to open at the same time */
     68#define FOPEN_MAX VFS_MAX_OPEN_FILES
     69
     70/** Recommended size of fixed-size array for holding file names. */
     71#define FILENAME_MAX 4096
     72
     73/** Length of "/tmp/tmp.XXXXXX" + 1 */
     74#define L_tmpnam 16
     75
     76#ifndef SEEK_SET
     77#define SEEK_SET  0
     78#endif
     79
     80#ifndef SEEK_CUR
     81#define SEEK_CUR  1
     82#endif
     83
     84#ifndef SEEK_END
     85#define SEEK_END  2
     86#endif
     87
     88/** Minimum number of unique temporary file names */
     89#define TMP_MAX 1000000
    6790
    6891extern FILE *stdin;
    … …  
    7497extern int fgetc(FILE *);
    7598extern char *fgets(char *, int, FILE *);
     99extern char *gets(char *, size_t) __attribute__((deprecated));
    76100
    77101extern int getchar(void);
    … …  
    104128extern int vasprintf(char **, const char *, va_list);
    105129extern int asprintf(char **, const char *, ...)
    106 #endif
    107130    _HELENOS_PRINTF_ATTRIBUTE(2, 3);
     131#endif
    108132extern int vsnprintf(char *, size_t, const char *, va_list);
     133
     134extern int sprintf(char *, const char *, ...)
     135    __attribute__((deprecated)) _HELENOS_PRINTF_ATTRIBUTE(2, 3);
     136extern int vsprintf(char *, const char *, va_list) __attribute__((deprecated));
    109137
    110138/* Formatted input */
    … …  
    124152extern size_t fwrite(const void *, size_t, size_t, FILE *);
    125153
     154extern int fgetpos(FILE *, fpos_t *);
     155extern int fsetpos(FILE *, const fpos_t *);
     156
    126157extern int fseek(FILE *, long, int);
    127158extern void rewind(FILE *);
    … …  
    133164extern void clearerr(FILE *);
    134165
     166extern void perror(const char *);
     167
    135168extern void setvbuf(FILE *, void *, int, size_t);
    136169extern void setbuf(FILE *, void *);
    137170
    138171/* Misc file functions */
     172extern int remove(const char *);
    139173extern int rename(const char *, const char *);
    140 extern int remove(const char *);
    141 
    142 #ifndef _HELENOS_SOURCE
    143 #define _IONBF 0
    144 #define _IOLBF 1
    145 #define _IOFBF 2
    146 
    147 extern char *gets(char *, size_t);
    148 
    149 #endif
     174
     175extern FILE *tmpfile(void);
     176extern char *tmpnam(char *s) __attribute__((deprecated));
    150177
    151178#ifdef _HELENOS_SOURCE

  • uspace/lib/c/include/stdlib.h

    re768aea r8119363  
    8787extern int system(const char *);
    8888
     89extern int abs(int);
     90extern long labs(long);
     91extern long long llabs(long long);
     92
    8993extern int atoi(const char *);
    9094extern long atol(const char *);

  • uspace/lib/c/include/vfs/vfs.h

    re768aea r8119363  
    4545#include <offset.h>
    4646
    47 #define MAX_OPEN_FILES  128
     47#define VFS_MAX_OPEN_FILES  128
    4848
    4949enum vfs_change_state_type {

  • uspace/lib/c/test/main.c

    re768aea r8119363  
    3434PCUT_IMPORT(circ_buf);
    3535PCUT_IMPORT(fibril_timer);
     36PCUT_IMPORT(mem);
    3637PCUT_IMPORT(odict);
    3738PCUT_IMPORT(qsort);
    3839PCUT_IMPORT(scanf);
    3940PCUT_IMPORT(sprintf);
     41PCUT_IMPORT(stdio);
    4042PCUT_IMPORT(stdlib);
    4143PCUT_IMPORT(str);

  • uspace/lib/c/test/stdlib.c

    re768aea r8119363  
    361361}
    362362
     363/** abs function of positive number */
     364PCUT_TEST(abs_pos)
     365{
     366        int i;
     367
     368        i = abs(1);
     369        PCUT_ASSERT_TRUE(i == 1);
     370}
     371
     372/** abs function of negative number */
     373PCUT_TEST(abs_neg)
     374{
     375        int i;
     376
     377        i = abs(-1);
     378        PCUT_ASSERT_TRUE(i == 1);
     379}
     380
     381/** labs function of positive number */
     382PCUT_TEST(labs_pos)
     383{
     384        long li;
     385
     386        li = labs(1);
     387        PCUT_ASSERT_TRUE(li == 1);
     388}
     389
     390/** labs function of negative number */
     391PCUT_TEST(labs_neg)
     392{
     393        long li;
     394
     395        li = labs(-1);
     396        PCUT_ASSERT_TRUE(li == 1);
     397}
     398
     399/** llabs function of positive number */
     400PCUT_TEST(llabs_pos)
     401{
     402        long long lli;
     403
     404        lli = llabs(1);
     405        PCUT_ASSERT_TRUE(lli == 1);
     406}
     407
     408/** llabs function of negative number */
     409PCUT_TEST(llabs_neg)
     410{
     411        long long lli;
     412
     413        lli = llabs(-1);
     414        PCUT_ASSERT_TRUE(lli == 1);
     415}
     416
    363417/** Integer division */
    364418PCUT_TEST(div_func)

  • uspace/lib/drv/include/pci_dev_iface.h

    re768aea r8119363  
    4242#define PCI_VENDOR_ID   0x00
    4343#define PCI_DEVICE_ID   0x02
     44#define PCI_STATUS      0x06
    4445#define PCI_SUB_CLASS   0x0A
    4546#define PCI_BASE_CLASS  0x0B
     47#define PCI_BAR0        0x10
     48#define PCI_CAP_PTR     0x34
     49
     50#define PCI_BAR_COUNT   6
     51
     52#define PCI_STATUS_CAP_LIST     (1 << 4)
     53
     54#define PCI_CAP_ID(c)   ((c) + 0x0)
     55#define PCI_CAP_NEXT(c) ((c) + 0x1)
     56
     57#define PCI_CAP_PMID            0x1
     58#define PCI_CAP_VENDORSPECID    0x9
    4659
    4760extern errno_t pci_config_space_read_8(async_sess_t *, uint32_t, uint8_t *);
    … …  
    5265extern errno_t pci_config_space_write_16(async_sess_t *, uint32_t, uint16_t);
    5366extern errno_t pci_config_space_write_32(async_sess_t *, uint32_t, uint32_t);
     67
     68static inline errno_t
     69pci_config_space_cap_first(async_sess_t *sess, uint8_t *c, uint8_t *id)
     70{
     71        errno_t rc;
     72        uint16_t status;
     73
     74        rc = pci_config_space_read_16(sess, PCI_STATUS, &status);
     75        if (rc != EOK)
     76                return rc;
     77
     78        if (!(status & PCI_STATUS_CAP_LIST)) {
     79                *c = 0;
     80                return EOK;
     81        }
     82
     83        rc = pci_config_space_read_8(sess, PCI_CAP_PTR, c);
     84        if (rc != EOK)
     85                return rc;
     86        if (!c)
     87                return EOK;
     88        return pci_config_space_read_8(sess, PCI_CAP_ID(*c), id);
     89}
     90
     91static inline errno_t
     92pci_config_space_cap_next(async_sess_t *sess, uint8_t *c, uint8_t *id)
     93{
     94        errno_t rc = pci_config_space_read_8(sess, PCI_CAP_NEXT(*c), c);
     95        if (rc != EOK)
     96                return rc;
     97        if (!c)
     98                return EOK;
     99        return pci_config_space_read_8(sess, PCI_CAP_ID(*c), id);
     100}
    54101
    55102/** PCI device communication interface. */

  • uspace/lib/posix/Makefile

    re768aea r8119363  
    8282TEST_SOURCES = \
    8383        test/main.c \
    84         test/scanf.c
     84        test/stdio.c \
     85        test/stdlib.c \
     86        test/unistd.c
     87
     88EXTRA_TEST_CFLAGS = -Wno-deprecated-declarations
    8589
    8690EXPORT_CPPFLAGS = \

  • uspace/lib/posix/include/posix/stdio.h

    re768aea r8119363  
    4848extern int fileno(FILE *);
    4949
     50#define P_tmpdir "/tmp"
     51
    5052/* Identifying the Terminal */
    5153#undef L_ctermid
    … …  
    5961    FILE *__restrict__ stream);
    6062
    61 /* Error Messages */
    62 extern void perror(const char *s);
    63 
    64 /* File Positioning */
    65 typedef struct {
    66         off64_t offset;
    67 } fpos_t;
    68 
    69 extern int fsetpos(FILE *stream, const fpos_t *pos);
    70 extern int fgetpos(FILE *__restrict__ stream, fpos_t *__restrict__ pos);
    7163extern int fseeko(FILE *stream, off_t offset, int whence);
    7264extern off_t ftello(FILE *stream);
    … …  
    7668    _HELENOS_PRINTF_ATTRIBUTE(2, 3);
    7769extern int vdprintf(int fildes, const char *__restrict__ format, va_list ap);
    78 extern int sprintf(char *__restrict__ s, const char *__restrict__ format, ...)
    79     _HELENOS_PRINTF_ATTRIBUTE(2, 3);
    80 extern int vsprintf(char *__restrict__ s, const char *__restrict__ format, va_list ap);
    8170
    8271/* File Locking */
    … …  
    9079
    9180/* Temporary Files */
    92 #undef L_tmpnam
    93 #define L_tmpnam PATH_MAX
    94 extern char *tmpnam(char *s);
    9581extern char *tempnam(const char *dir, const char *pfx);
    96 extern FILE *tmpfile(void);
    9782
    9883#endif /* POSIX_STDIO_H_ */

  • uspace/lib/posix/include/posix/stdlib.h

    re768aea r8119363  
    4242#include <_bits/NULL.h>
    4343
    44 /* Absolute Value */
    45 extern int abs(int i);
    46 extern long labs(long i);
    47 extern long long llabs(long long i);
    48 
    4944/* Environment Access */
    5045extern int putenv(char *string);
    … …  
    6358
    6459/* Legacy Declarations */
    65 extern char *mktemp(char *tmpl);
     60extern char *mktemp(char *tmpl) __attribute__((deprecated));
    6661extern int bsd_getloadavg(double loadavg[], int nelem);
    6762

  • uspace/lib/posix/include/posix/string.h

    re768aea r8119363  
    3636#ifndef POSIX_STRING_H_
    3737#define POSIX_STRING_H_
    38 
    39 #include "sys/types.h"
    40 
    4138/*
    4239 * TODO: not implemented due to missing locale support
    … …  
    4845
    4946#include <_bits/NULL.h>
     47#include <_bits/size_t.h>
    5048
    51 /*
    52  * These are the same as in HelenOS libc.
    53  * It would be possible to directly include <str.h> and <mem.h> but
    54  * it is better not to pollute POSIX namespace with other functions
    55  * defined in that header.
    56  *
    57  * Because libposix is always linked with libc, providing only these
    58  * forward declarations ought to be enough.
    59  */
    60 
    61 /* From mem.h */
    62 // #define bzero(ptr, len)  memset((ptr), 0, (len))
    63 extern void *memset(void *, int, size_t)
    64     __attribute__((nonnull(1)));
    65 extern void *memcpy(void *, const void *, size_t)
    66     __attribute__((nonnull(1, 2)));
    67 extern void *memmove(void *, const void *, size_t)
    68     __attribute__((nonnull(1, 2)));
    69 
     49#include "libc/mem.h"
    7050
    7151/* Copying and Concatenation */
    … …  
    8060extern char *strndup(const char *s, size_t n);
    8161
    82 /* String/Array Comparison */
    83 extern int memcmp(const void *mem1, const void *mem2, size_t n);
     62/* String Comparison */
    8463extern int strcmp(const char *s1, const char *s2);
    8564extern int strncmp(const char *s1, const char *s2, size_t n);
    8665
    8766/* Search Functions */
    88 extern void *memchr(const void *mem, int c, size_t n);
    8967extern char *strchr(const char *s, int c);
    9068extern char *strrchr(const char *s, int c);
    … …  
    122100#endif
    123101
    124 
    125102#endif  // POSIX_STRING_H_
    126103

  • uspace/lib/posix/src/internal/common.h

    re768aea r8119363  
    6666}
    6767
    68 extern aoff64_t posix_pos[MAX_OPEN_FILES];
     68extern aoff64_t posix_pos[VFS_MAX_OPEN_FILES];
    6969
    7070#endif /* LIBPOSIX_COMMON_H_ */

  • uspace/lib/posix/src/stdio.c

    re768aea r8119363  
    22 * Copyright (c) 2011 Jiri Zarevucky
    33 * Copyright (c) 2011 Petr Koupy
     4 * Copyright (c) 2018 Jiri Svoboda
    45 * All rights reserved.
    56 *
    … …  
    3839
    3940#include <assert.h>
    40 
    4141#include <errno.h>
    42 
     42#include <stdbool.h>
     43#include <tmpfile.h>
     44
     45#include "posix/fcntl.h"
    4346#include "posix/stdlib.h"
    4447#include "posix/string.h"
     48#include "posix/sys/stat.h"
    4549#include "posix/sys/types.h"
    4650#include "posix/unistd.h"
    … …  
    169173
    170174/**
    171  * Write error messages to standard error.
    172  *
    173  * @param s Error message.
    174  */
    175 void perror(const char *s)
    176 {
    177         if (s == NULL || s[0] == '\0') {
    178                 fprintf(stderr, "%s\n", strerror(errno));
    179         } else {
    180                 fprintf(stderr, "%s: %s\n", s, strerror(errno));
    181         }
    182 }
    183 
    184 /** Restores stream a to position previously saved with fgetpos().
    185  *
    186  * @param stream Stream to restore
    187  * @param pos Position to restore
    188  * @return Zero on success, non-zero (with errno set) on failure
    189  */
    190 int fsetpos(FILE *stream, const fpos_t *pos)
    191 {
    192         return fseek64(stream, pos->offset, SEEK_SET);
    193 }
    194 
    195 /** Saves the stream's position for later use by fsetpos().
    196  *
    197  * @param stream Stream to save
    198  * @param pos Place to store the position
    199  * @return Zero on success, non-zero (with errno set) on failure
    200  */
    201 int fgetpos(FILE *restrict stream, fpos_t *restrict pos)
    202 {
    203         off64_t ret = ftell64(stream);
    204         if (ret != -1) {
    205                 pos->offset = ret;
    206                 return 0;
    207         } else {
    208                 return -1;
    209         }
    210 }
    211 
    212 /**
    213175 * Reposition a file-position indicator in a stream.
    214176 *
    … …  
    320282
    321283/**
    322  * Print formatted output to the string.
    323  *
    324  * @param s Output string.
    325  * @param format Format description.
    326  * @return Either the number of printed characters (excluding null byte) or
    327  *     negative value on error.
    328  */
    329 int sprintf(char *s, const char *restrict format, ...)
    330 {
    331         va_list list;
    332         va_start(list, format);
    333         int result = vsprintf(s, format, list);
    334         va_end(list);
    335         return result;
    336 }
    337 
    338 /**
    339  * Print formatted output to the string.
    340  *
    341  * @param s Output string.
    342  * @param format Format description.
    343  * @param ap Print arguments.
    344  * @return Either the number of printed characters (excluding null byte) or
    345  *     negative value on error.
    346  */
    347 int vsprintf(char *s, const char *restrict format, va_list ap)
    348 {
    349         return vsnprintf(s, INT_MAX, format, ap);
    350 }
    351 
    352 /**
    353284 * Acquire file stream for the thread.
    354285 *
    … …  
    426357}
    427358
    428 /**
    429  * Get a unique temporary file name (obsolete).
    430  *
    431  * @param s Buffer for the file name. Must be at least L_tmpnam bytes long.
    432  * @return The value of s on success, NULL on failure.
    433  */
    434 char *tmpnam(char *s)
    435 {
    436         assert(L_tmpnam >= strlen("/tmp/tnXXXXXX"));
    437 
    438         static char buffer[L_tmpnam + 1];
    439         if (s == NULL) {
    440                 s = buffer;
    441         }
    442 
    443         strcpy(s, "/tmp/tnXXXXXX");
    444         mktemp(s);
    445 
    446         if (*s == '\0') {
    447                 /* Errno set by mktemp(). */
    448                 return NULL;
    449         }
    450 
    451         return s;
    452 }
    453 
    454 /**
    455  * Get an unique temporary file name with additional constraints (obsolete).
     359/** Determine if directory is an 'appropriate' temporary directory.
     360 *
     361 * @param dir Directory path
     362 * @return @c true iff directory is appropriate.
     363 */
     364static bool is_appropriate_tmpdir(const char *dir)
     365{
     366        struct stat sbuf;
     367
     368        /* Must not be NULL */
     369        if (dir == NULL)
     370                return false;
     371
     372        /* Must not be empty */
     373        if (dir[0] == '\0')
     374                return false;
     375
     376        if (stat(dir, &sbuf) != 0)
     377                return false;
     378
     379        /* Must be a directory */
     380        if ((sbuf.st_mode & S_IFMT) != S_IFDIR)
     381                return false;
     382
     383        /* Must be writable */
     384        if (access(dir, W_OK) != 0)
     385                return false;
     386
     387        return true;
     388}
     389
     390/** Construct unique file name.
     391 *
     392 * Never use this function.
    456393 *
    457394 * @param dir Path to directory, where the file should be created.
    … …  
    461398char *tempnam(const char *dir, const char *pfx)
    462399{
    463         /* Sequence number of the filename. */
    464         static int seq = 0;
    465 
    466         size_t dir_len = strlen(dir);
    467         if (dir[dir_len - 1] == '/') {
    468                 dir_len--;
    469         }
    470 
    471         size_t pfx_len = strlen(pfx);
    472         if (pfx_len > 5) {
    473                 pfx_len = 5;
    474         }
    475 
    476         char *result = malloc(dir_len + /* slash*/ 1 +
    477             pfx_len + /* three-digit seq */ 3 + /* .tmp */ 4 + /* nul */ 1);
    478 
    479         if (result == NULL) {
    480                 errno = ENOMEM;
     400        const char *dpref;
     401        char *d;
     402        char *buf;
     403        int rc;
     404
     405        d = getenv("TMPDIR");
     406        if (is_appropriate_tmpdir(d))
     407                dpref = d;
     408        else if (is_appropriate_tmpdir(dir))
     409                dpref = dir;
     410        else if (is_appropriate_tmpdir(P_tmpdir))
     411                dpref = P_tmpdir;
     412        else
     413                dpref = "/";
     414
     415        if (dpref[strlen(dpref) - 1] != '/')
     416                rc = asprintf(&buf, "%s/%sXXXXXX", dpref, pfx);
     417        else
     418                rc = asprintf(&buf, "%s%sXXXXXX", dpref, pfx);
     419
     420        if (rc < 0)
     421                return NULL;
     422
     423        rc = __tmpfile_templ(buf, false);
     424        if (rc != 0) {
     425                free(buf);
    481426                return NULL;
    482427        }
    483428
    484         char *res_ptr = result;
    485         strncpy(res_ptr, dir, dir_len);
    486         res_ptr += dir_len;
    487         strncpy(res_ptr, pfx, pfx_len);
    488         res_ptr += pfx_len;
    489 
    490         for (; seq < 1000; ++seq) {
    491                 snprintf(res_ptr, 8, "%03d.tmp", seq);
    492 
    493                 int orig_errno = errno;
    494                 errno = EOK;
    495                 /* Check if the file exists. */
    496                 if (access(result, F_OK) == -1) {
    497                         if (errno == ENOENT) {
    498                                 errno = orig_errno;
    499                                 break;
    500                         } else {
    501                                 /* errno set by access() */
    502                                 return NULL;
    503                         }
    504                 }
    505         }
    506 
    507         if (seq == 1000) {
    508                 free(result);
    509                 errno = EINVAL;
    510                 return NULL;
    511         }
    512 
    513         return result;
    514 }
    515 
    516 /**
    517  * Create and open an unique temporary file.
    518  * The file is automatically removed when the stream is closed.
    519  *
    520  * @param dir Path to directory, where the file should be created.
    521  * @param pfx Optional prefix up to 5 characters long.
    522  * @return Newly allocated unique path for temporary file. NULL on failure.
    523  */
    524 FILE *tmpfile(void)
    525 {
    526         char filename[] = "/tmp/tfXXXXXX";
    527         int fd = mkstemp(filename);
    528         if (fd == -1) {
    529                 /* errno set by mkstemp(). */
    530                 return NULL;
    531         }
    532 
    533         /* Unlink the created file, so that it's removed on close(). */
    534         unlink(filename);
    535         return fdopen(fd, "w+");
     429        return buf;
    536430}
    537431

  • uspace/lib/posix/src/stdlib.c

    re768aea r8119363  
    3838
    3939#include <errno.h>
     40#include <tmpfile.h>
    4041
    4142#include "posix/fcntl.h"
    … …  
    4950#include "libc/vfs/vfs.h"
    5051#include "libc/stats.h"
    51 
    52 /**
    53  * Integer absolute value.
    54  *
    55  * @param i Input value.
    56  * @return Absolute value of the parameter.
    57  */
    58 int abs(int i)
    59 {
    60         return i < 0 ? -i : i;
    61 }
    62 
    63 /**
    64  * Long integer absolute value.
    65  *
    66  * @param i Input value.
    67  * @return Absolute value of the parameter.
    68  */
    69 long labs(long i)
    70 {
    71         return i < 0 ? -i : i;
    72 }
    73 
    74 /**
    75  * Long long integer absolute value.
    76  *
    77  * @param i Input value.
    78  * @return Absolute value of the parameter.
    79  */
    80 long long llabs(long long i)
    81 {
    82         return i < 0 ? -i : i;
    83 }
    8452
    8553/**
    … …  
    196164int mkstemp(char *tmpl)
    197165{
    198         int fd = -1;
    199 
    200         char *tptr = tmpl + strlen(tmpl) - 6;
    201 
    202         while (fd < 0) {
    203                 if (*mktemp(tmpl) == '\0') {
    204                         /* Errno set by mktemp(). */
    205                         return -1;
    206                 }
    207 
    208                 fd = open(tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
    209 
    210                 if (fd == -1) {
    211                         /* Restore template to it's original state. */
    212                         snprintf(tptr, 7, "XXXXXX");
    213                 }
    214         }
    215 
    216         return fd;
     166        int tmpl_len;
     167        int file;
     168
     169        tmpl_len = strlen(tmpl);
     170        if (tmpl_len < 6) {
     171                errno = EINVAL;
     172                return -1;
     173        }
     174
     175        char *tptr = tmpl + tmpl_len - 6;
     176        if (strcmp(tptr, "XXXXXX") != 0) {
     177                errno = EINVAL;
     178                return -1;
     179        }
     180
     181        file = __tmpfile_templ(tmpl, true);
     182        if (file < 0) {
     183                errno = EIO; // XXX could be more specific
     184                return -1;
     185        }
     186
     187        return file;
    217188}
    218189
    … …  
    227198char *mktemp(char *tmpl)
    228199{
    229         int tmpl_len = strlen(tmpl);
     200        int tmpl_len;
     201        int rc;
     202
     203        tmpl_len = strlen(tmpl);
    230204        if (tmpl_len < 6) {
    231205                errno = EINVAL;
    … …  
    241215        }
    242216
    243         static int seq = 0;
    244 
    245         for (; seq < 1000000; ++seq) {
    246                 snprintf(tptr, 7, "%06d", seq);
    247 
    248                 int orig_errno = errno;
    249                 errno = 0;
    250                 /* Check if the file exists. */
    251                 if (access(tmpl, F_OK) == -1) {
    252                         if (errno == ENOENT) {
    253                                 errno = orig_errno;
    254                                 break;
    255                         } else {
    256                                 /* errno set by access() */
    257                                 *tmpl = '\0';
    258                                 return tmpl;
    259                         }
    260                 }
    261         }
    262 
    263         if (seq == 10000000) {
    264                 errno = EEXIST;
     217        rc = __tmpfile_templ(tmpl, false);
     218        if (rc != 0) {
     219                errno = EIO; // XXX could be more specific
    265220                *tmpl = '\0';
    266221                return tmpl;

  • uspace/lib/posix/src/stdlib/strtold.c

    re768aea r8119363  
    5252#ifndef HUGE_VALL
    5353#define HUGE_VALL (+1.0l / +0.0l)
    54 #endif
    55 
    56 #ifndef abs
    57 #define abs(x) (((x) < 0) ? -(x) : (x))
    5854#endif
    5955

  • uspace/lib/posix/src/string.c

    re768aea r8119363  
    288288
    289289        return 0;
    290 }
    291 
    292 /**
    293  * Find byte in memory.
    294  *
    295  * @param mem Memory area in which to look for the byte.
    296  * @param c Byte to look for.
    297  * @param n Maximum number of bytes to be inspected.
    298  * @return Pointer to the specified byte on success,
    299  *     NULL pointer otherwise.
    300  */
    301 void *memchr(const void *mem, int c, size_t n)
    302 {
    303         assert(mem != NULL);
    304 
    305         const unsigned char *s = mem;
    306 
    307         for (size_t i = 0; i < n; ++i) {
    308                 if (s[i] == (unsigned char) c) {
    309                         return (void *) &s[i];
    310                 }
    311         }
    312         return NULL;
    313290}
    314291

  • uspace/lib/posix/src/unistd.c

    re768aea r8119363  
    3939#include <errno.h>
    4040
     41#include "posix/dirent.h"
    4142#include "posix/string.h"
     43#include "posix/sys/types.h"
    4244#include "posix/fcntl.h"
    4345
    … …  
    5153
    5254// FIXME: replace with a hash table
    53 aoff64_t posix_pos[MAX_OPEN_FILES];
     55aoff64_t posix_pos[VFS_MAX_OPEN_FILES];
    5456
    5557/* Array of environment variable strings (NAME=VALUE). */
    … …  
    368370                 */
    369371                int fd = open(path, O_RDONLY);
    370                 if (fd < 0)
    371                         return -1;
    372                 close(fd);
    373                 return 0;
     372                if (fd >= 0) {
     373                        close(fd);
     374                        return 0;
     375                }
     376                DIR *dir = opendir(path);
     377                if (dir != NULL) {
     378                        closedir(dir);
     379                        return 0;
     380                }
     381                return -1;
    374382        } else {
    375383                /* Invalid amode argument. */

  • uspace/lib/posix/test/main.c

    re768aea r8119363  
    11/*
    2  * Copyright (c) 2014 Vojtech Horky
     2 * Copyright (c) 2018 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3131PCUT_INIT;
    3232
    33 PCUT_IMPORT(scanf);
     33PCUT_IMPORT(stdio);
     34PCUT_IMPORT(stdlib);
     35PCUT_IMPORT(unistd);
    3436
    3537PCUT_MAIN();

  • uspace/srv/vfs/vfs_file.c

    re768aea r8119363  
    7171        fibril_mutex_lock(&vfs_data->lock);
    7272        if (!vfs_data->files) {
    73                 vfs_data->files = malloc(MAX_OPEN_FILES * sizeof(vfs_file_t *));
     73                vfs_data->files = malloc(VFS_MAX_OPEN_FILES * sizeof(vfs_file_t *));
    7474                if (!vfs_data->files) {
    7575                        fibril_mutex_unlock(&vfs_data->lock);
    7676                        return false;
    7777                }
    78                 memset(vfs_data->files, 0, MAX_OPEN_FILES * sizeof(vfs_file_t *));
     78                memset(vfs_data->files, 0, VFS_MAX_OPEN_FILES * sizeof(vfs_file_t *));
    7979        }
    8080        fibril_mutex_unlock(&vfs_data->lock);
    … …  
    9090                return;
    9191
    92         for (i = 0; i < MAX_OPEN_FILES; i++) {
     92        for (i = 0; i < VFS_MAX_OPEN_FILES; i++) {
    9393                if (vfs_data->files[i])
    9494                        (void) _vfs_fd_free(vfs_data, i);
    … …  
    199199        unsigned int i;
    200200        if (desc)
    201                 i = MAX_OPEN_FILES - 1;
     201                i = VFS_MAX_OPEN_FILES - 1;
    202202        else
    203203                i = 0;
    … …  
    233233                        i--;
    234234                } else {
    235                         if (i == MAX_OPEN_FILES - 1)
     235                        if (i == VFS_MAX_OPEN_FILES - 1)
    236236                                break;
    237237
    … …  
    261261static errno_t _vfs_fd_free_locked(vfs_client_data_t *vfs_data, int fd)
    262262{
    263         if ((fd < 0) || (fd >= MAX_OPEN_FILES) || !vfs_data->files[fd]) {
     263        if ((fd < 0) || (fd >= VFS_MAX_OPEN_FILES) || !vfs_data->files[fd]) {
    264264                return EBADF;
    265265        }
    … …  
    311311
    312312        fibril_mutex_lock(&VFS_DATA->lock);
    313         if ((fd < 0) || (fd >= MAX_OPEN_FILES)) {
     313        if ((fd < 0) || (fd >= VFS_MAX_OPEN_FILES)) {
    314314                fibril_mutex_unlock(&VFS_DATA->lock);
    315315                return EBADF;
    … …  
    342342
    343343        fibril_mutex_lock(&vfs_data->lock);
    344         if ((fd >= 0) && (fd < MAX_OPEN_FILES)) {
     344        if ((fd >= 0) && (fd < VFS_MAX_OPEN_FILES)) {
    345345                vfs_file_t *file = vfs_data->files[fd];
    346346                if (file != NULL) {
Note: See TracChangeset for help on using the changeset viewer.