Changes in / [90924df:f3378ba] in mainline


Ignore:
Files:
9 deleted
21 edited

Legend:

Unmodified
Added
Removed
  • tools/checkers/clang.py

    r90924df rf3378ba  
    114114        for job in jobs:
    115115                if (not clang(rootdir, job)):
    116                         print()
     116                        print
    117117                        print("Failed job: %s" % job)
    118118                        return
  • tools/checkers/stanse.py

    r90924df rf3378ba  
    127127        for job in jobs:
    128128                if (not stanse(rootdir, job)):
    129                         print()
     129                        print
    130130                        print("Failed job: %s" % job)
    131131                        return
  • tools/checkers/vcc.py

    r90924df rf3378ba  
    204204        for job in jobs:
    205205                if (not vcc(vcc_path, rootdir, job)):
    206                         print()
     206                        print
    207207                        print("Failed job: %s" % job)
    208208                        return
    209209       
    210         print()
     210        print
    211211        print("All jobs passed")
    212212
  • tools/filldir.py

    r90924df rf3378ba  
    3737
    3838if len(sys.argv) < 3:
    39         print('Usage: filldir <parent-dir> <count>')
     39        print 'Usage: filldir <parent-dir> <count>'
    4040        exit(2)
    4141
  • tools/gentestfile.py

    r90924df rf3378ba  
    3636
    3737if len(sys.argv) < 2:
    38         print("Usage: gentestfile.py <count of 64-bit numbers to output>")
     38        print "Usage: gentestfile.py <count of 64-bit numbers to output>"
    3939        exit()
    4040
    41 m = int(sys.argv[1])
     41m = long(sys.argv[1])
    4242i = 0
    4343pow_2_64 = 2 ** 64
  • tools/mkfat.py

    r90924df rf3378ba  
    247247        return bs
    248248
    249 def create_lfn_entry(name_index) :
    250         (name, index) = name_index
     249def create_lfn_entry((name, index)) :
    251250        entry = xstruct.create(LFN_ENTRY)
    252251
     
    294293                return [dir_entry]
    295294
    296         n = (int) (len(name) / 13 + 1)
     295        n = len(name) / 13 + 1
    297296        names = [(name[i * 13: (i + 1) * 13 + 1], i + 1) for i in range(n)]
    298297
     
    300299        entries[0].pos |= 0x40
    301300
    302         fname11 = str(dir_entry.name + dir_entry.ext)
     301        fname11 = dir_entry.name + dir_entry.ext
    303302
    304303        csum = 0
  • tools/mkuimage.py

    r90924df rf3378ba  
    124124        header.img_type = 2             # Kernel
    125125        header.compression = 0          # None
    126         header.img_name = image_name.encode('ascii')
     126        header.img_name = image_name
    127127
    128128        header_crc = calc_crc32(header.pack())
     
    140140        signed_crc = zlib.crc32(byteseq, 0)
    141141        if signed_crc < 0:
    142                 return signed_crc + (1 << 32)
     142                return (long(signed_crc) + (long(2) ** long(32))) # 2^32L
    143143        else:
    144144                return signed_crc
     
    148148def print_syntax(cmd):
    149149        print("syntax: " + cmd + " [<options>] <raw_image> <uImage>")
    150         print()
     150        print
    151151        print("\traw_image\tInput image name (raw binary data)")
    152152        print("\tuImage\t\tOutput uImage name (U-Boot image)")
    153         print()
     153        print
    154154        print("options:")
    155155        print("\t-name <name>\tImage name (default: 'Noname')")
  • tools/xstruct.py

    r90924df rf3378ba  
    3232
    3333import struct
    34 import sys
    3534import types
    3635
    37 integer_types = (int, long) if sys.version < '3' else (int,)
    38 
    3936ranges = {
    40         'B': (integer_types, 0x00, 0xff),
    41         'H': (integer_types, 0x0000, 0xffff),
    42         'L': (integer_types, 0x00000000, 0xffffffff),
    43         'Q': (integer_types, 0x0000000000000000, 0xffffffffffffffff),
    44         'b': (integer_types, -0x80, 0x7f),
    45         'h': (integer_types, -0x8000, 0x7fff),
    46         'l': (integer_types, -0x80000000, 0x7fffffff) ,
    47         'q': (integer_types, -0x8000000000000000, 0x7fffffffffffffff),
     37        'B': ((int, long), 0x00, 0xff),
     38        'H': ((int, long), 0x0000, 0xffff),
     39        'L': ((int, long), 0x00000000, 0xffffffff),
     40        'Q': ((int, long), 0x0000000000000000, 0xffffffffffffffff),
     41        'b': ((int, long), -0x80, 0x7f),
     42        'h': ((int, long), -0x8000, 0x7fff),
     43        'l': ((int, long), -0x80000000, 0x7fffffff) ,
     44        'q': ((int, long), -0x8000000000000000, 0x7fffffffffffffff),
    4845}
    4946
  • uspace/app/bdsh/Makefile

    r90924df rf3378ba  
    4848        cmds/modules/cp/cp.c \
    4949        cmds/modules/mv/mv.c \
    50         cmds/modules/printf/printf.c \
    51         cmds/modules/echo/echo.c \
    5250        cmds/modules/mount/mount.c \
    5351        cmds/modules/unmount/unmount.c \
  • uspace/app/bdsh/TODO

    r90924df rf3378ba  
    3030* Add wrappers for signal, sigaction to make ports to modules easier
    3131
     32* Add 'echo' and 'printf' modules.
     33
    3234Regarding POSIX:
    3335----------------
  • uspace/app/bdsh/cmds/builtins/cd/cd.c

    r90924df rf3378ba  
    6363        argc = cli_count_args(argv);
    6464
    65         /* Handle cd -- -. Override to switch to a directory named '-' */
    66         bool hyphen_override = false;
    67         if (argc == 3) {
    68                 if(!str_cmp(argv[1], "--")) {
    69                         hyphen_override = true;
    70                         argc--;
    71                 }
    72         }
    73 
    7465        /* We don't yet play nice with whitespace, a getopt implementation should
    7566         * protect "quoted\ destination" as a single argument. Its not our job to
     
    8879        }
    8980
    90         /* We have the correct # of arguments */
    91         // TODO: handle tidle (~) expansion? */
     81        /* We have the correct # of arguments
     82     * TODO: handle tidle (~) expansion? */
    9283
    93         /* Handle 'cd -' first. */
    94         if (!str_cmp(argv[1], "-") && !hyphen_override) {
    95                 char *buffer = (char *) malloc(PATH_MAX);
    96                 if (!buffer) {
    97                         cli_error(CL_ENOMEM, "Cannot switch to previous directory");
    98                         return CMD_FAILURE;
    99                 }
    100                 memset(buffer, 0, PATH_MAX);
    101                 getprevwd(buffer, PATH_MAX);
    102                 if (*buffer == '\0') {
    103                         cli_error(CL_EFAIL, "No previous directory to switch to");
    104                         free(buffer);
    105                         return CMD_FAILURE;
    106                 } else {
    107                         rc = chdir(buffer);
    108                         free(buffer);
    109                 }
    110         } else if (hyphen_override) {
    111                 /* Handles 'cd -- <dirname>'.
    112                  * Override for directory named '-'.
    113                  */
    114                 rc = chdir(argv[2]);
    115         } else {
    116                 rc = chdir(argv[1]);
    117         }
     84        rc = chdir(argv[1]);
    11885
    11986        if (rc == 0) {
  • uspace/app/bdsh/cmds/modules/cat/cat.h

    r90924df rf3378ba  
    44/* Prototypes for the cat command, excluding entry points */
    55
     6static unsigned int cat_file(const char *, size_t, bool, off64_t, off64_t, bool);
     7
    68#endif /* CAT_H */
    79
  • uspace/app/bdsh/cmds/modules/cp/cp.c

    r90924df rf3378ba  
    3030#include <stdlib.h>
    3131#include <unistd.h>
    32 #include <io/console.h>
    33 #include <io/keycode.h>
    3432#include <getopt.h>
    3533#include <str.h>
     
    4846
    4947static const char *cmdname = "cp";
    50 static console_ctrl_t *con;
    5148
    5249static struct option const long_options[] = {
    5350        { "buffer", required_argument, 0, 'b' },
    5451        { "force", no_argument, 0, 'f' },
    55         { "interactive", no_argument, 0, 'i'},
    5652        { "recursive", no_argument, 0, 'r' },
    5753        { "help", no_argument, 0, 'h' },
     
    143139}
    144140
    145 static bool get_user_decision(bool bdefault, const char *message, ...)
    146 {
    147         va_list args;
    148 
    149         va_start(args, message);
    150         vprintf(message, args);
    151         va_end(args);
    152 
    153         while (true) {
    154                 kbd_event_t ev;
    155                 console_flush(con);
    156                 console_get_kbd_event(con, &ev);
    157                 if ((ev.type != KEY_PRESS)
    158                     || (ev.mods & (KM_CTRL | KM_ALT)) != 0) {
    159                         continue;
    160                 }
    161 
    162                 switch(ev.key) {
    163                 case KC_Y:
    164                         printf("y\n");
    165                         return true;
    166                 case KC_N:
    167                         printf("n\n");
    168                         return false;
    169                 case KC_ENTER:
    170                         printf("%c\n", bdefault ? 'Y' : 'N');
    171                         return bdefault;
    172                 default:
    173                         break;
    174                 }
    175         }
    176 }
    177 
    178141static int64_t do_copy(const char *src, const char *dest,
    179     size_t blen, int vb, int recursive, int force, int interactive)
     142    size_t blen, int vb, int recursive, int force)
    180143{
    181144        int r = -1;
     
    229192                        /* e.g. cp file_name existing_file */
    230193
    231                         /* dest already exists,
    232                          * if force is set we will try to remove it.
    233                          * if interactive is set user input is required.
     194                        /* dest already exists, if force is set we will
     195                         * try to remove it.
    234196                         */
    235                         if (force && !interactive) {
     197                        if (force) {
    236198                                if (unlink(dest_path)) {
    237199                                        printf("Unable to remove %s\n",
     
    239201                                        goto exit;
    240202                                }
    241                         } else if (!force && interactive) {
    242                                 bool overwrite = get_user_decision(false,
    243                                     "File already exists: %s. Overwrite? [y/N]: ",
    244                                     dest_path);
    245                                 if (overwrite) {
    246                                         printf("Overwriting file: %s\n", dest_path);
    247                                         if (unlink(dest_path)) {
    248                                                 printf("Unable to remove %s\n", dest_path);
    249                                                 goto exit;
    250                                         }
    251                                 } else {
    252                                         printf("Not overwriting file: %s\n", dest_path);
    253                                         r = 0;
    254                                         goto exit;
    255                                 }
    256203                        } else {
    257                                 printf("File already exists: %s\n", dest_path);
     204                                printf("file already exists: %s\n", dest_path);
    258205                                goto exit;
    259206                        }
     
    355302                        /* Recursively call do_copy() */
    356303                        r = do_copy(src_dent, dest_dent, blen, vb, recursive,
    357                             force, interactive);
     304                            force);
    358305                        if (r)
    359306                                goto exit;
     
    368315        return r;
    369316}
     317
    370318
    371319static int64_t copy_file(const char *src, const char *dest,
     
    432380            "  -v, --version    Print version information and exit\n"
    433381            "  -V, --verbose    Be annoyingly noisy about what's being done\n"
    434             "  -f, --force      Do not complain when <dest> exists (overrides a previous -i)\n"
    435             "  -i, --interactive Ask what to do when <dest> exists (overrides a previous -f)\n"
     382            "  -f, --force      Do not complain when <dest> exists\n"
    436383            "  -r, --recursive  Copy entire directories\n"
    437384            "  -b, --buffer ## Set the read buffer size to ##\n";
     
    450397        unsigned int argc, verbose = 0;
    451398        int buffer = 0, recursive = 0;
    452         int force = 0, interactive = 0;
     399        int force = 0;
    453400        int c, opt_ind;
    454401        int64_t ret;
    455402
    456         con = console_init(stdin, stdout);
    457403        argc = cli_count_args(argv);
    458404
    459405        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    460                 c = getopt_long(argc, argv, "hvVfirb:", long_options, &opt_ind);
     406                c = getopt_long(argc, argv, "hvVfrb:", long_options, &opt_ind);
    461407                switch (c) {
    462408                case 'h':
     
    470416                        break;
    471417                case 'f':
    472                         interactive = 0;
    473418                        force = 1;
    474                         break;
    475                 case 'i':
    476                         force = 0;
    477                         interactive = 1;
    478419                        break;
    479420                case 'r':
     
    485426                                    "(should be a number greater than zero)\n",
    486427                                    cmdname);
    487                                 console_done(con);
    488428                                return CMD_FAILURE;
    489429                        }
     
    502442                printf("%s: invalid number of arguments. Try %s --help\n",
    503443                    cmdname, cmdname);
    504                 console_done(con);
    505444                return CMD_FAILURE;
    506445        }
    507446
    508447        ret = do_copy(argv[optind], argv[optind + 1], buffer, verbose,
    509             recursive, force, interactive);
    510 
    511         console_done(con);
     448            recursive, force);
    512449
    513450        if (ret == 0)
  • uspace/app/bdsh/cmds/modules/help/help.h

    r90924df rf3378ba  
    33
    44/* Prototypes for the help command (excluding entry points) */
     5static int is_mod_or_builtin(char *);
    56
    67#endif
  • uspace/app/bdsh/cmds/modules/mkdir/mkdir.h

    r90924df rf3378ba  
    44/* Prototypes for the mkdir command, excluding entry points */
    55
     6static unsigned int create_directory(const char *, unsigned int);
    67#endif /* MKDIR_H */
    78
  • uspace/app/bdsh/cmds/modules/modules.h

    r90924df rf3378ba  
    6161#include "unmount/entry.h"
    6262#include "kcon/entry.h"
    63 #include "printf/entry.h"
    64 #include "echo/entry.h"
    6563
    6664/* Each .def function fills the module_t struct with the individual name, entry
     
    8482#include "unmount/unmount_def.h"
    8583#include "kcon/kcon_def.h"
    86 #include "printf/printf_def.h"
    87 #include "echo/echo_def.h"
    8884
    8985        {NULL, NULL, NULL, NULL}
  • uspace/app/bdsh/cmds/modules/rm/rm.c

    r90924df rf3378ba  
    4646#define RM_VERSION "0.0.1"
    4747
     48static rm_job_t rm;
     49
    4850static struct option const long_options[] = {
    4951        { "help", no_argument, 0, 'h' },
     
    5557};
    5658
    57 /* Return values for rm_scope() */
    58 #define RM_BOGUS 0
    59 #define RM_FILE  1
    60 #define RM_DIR   2
    61 
    62 /* Flags for rm_update() */
    63 #define _RM_ENTRY   0
    64 #define _RM_ADVANCE 1
    65 #define _RM_REWIND  2
    66 #define _RM_EXIT    3
    67 
    68 /* A simple job structure */
    69 typedef struct {
    70         /* Options set at run time */
    71         unsigned int force;      /* -f option */
    72         unsigned int recursive;  /* -r option */
    73         unsigned int safe;       /* -s option */
    74 
    75         /* Keeps track of the job in progress */
    76         int advance; /* How far deep we've gone since entering */
    77         DIR *entry;  /* Entry point to the tree being removed */
    78         char *owd;   /* Where we were when we invoked rm */
    79         char *cwd;   /* Current directory being transversed */
    80         char *nwd;   /* Next directory to be transversed */
    81 
    82         /* Counters */
    83         int f_removed; /* Number of files unlinked */
    84         int d_removed; /* Number of directories unlinked */
    85 } rm_job_t;
    86 
    87 static rm_job_t rm;
    88 
    89 static unsigned int rm_recursive(const char *);
    90 
    9159static unsigned int rm_start(rm_job_t *rm)
    9260{
     
    12795        if (NULL != rm->cwd)
    12896                free(rm->cwd);
    129 }
    130 
    131 static unsigned int rm_single(const char *path)
    132 {
    133         if (unlink(path)) {
    134                 cli_error(CL_EFAIL, "rm: could not remove file %s", path);
    135                 return 1;
    136         }
    137         return 0;
    138 }
    139 
    140 static unsigned int rm_scope(const char *path)
    141 {
    142         int fd;
    143         DIR *dirp;
    144 
    145         dirp = opendir(path);
    146         if (dirp) {
    147                 closedir(dirp);
    148                 return RM_DIR;
    149         }
    150 
    151         fd = open(path, O_RDONLY);
    152         if (fd > 0) {
    153                 close(fd);
    154                 return RM_FILE;
    155         }
    156 
    157         return RM_BOGUS;
    15897}
    15998
     
    215154
    216155        return ret + 1;
     156}
     157
     158static unsigned int rm_single(const char *path)
     159{
     160        if (unlink(path)) {
     161                cli_error(CL_EFAIL, "rm: could not remove file %s", path);
     162                return 1;
     163        }
     164        return 0;
     165}
     166
     167static unsigned int rm_scope(const char *path)
     168{
     169        int fd;
     170        DIR *dirp;
     171
     172        dirp = opendir(path);
     173        if (dirp) {
     174                closedir(dirp);
     175                return RM_DIR;
     176        }
     177
     178        fd = open(path, O_RDONLY);
     179        if (fd > 0) {
     180                close(fd);
     181                return RM_FILE;
     182        }
     183
     184        return RM_BOGUS;
    217185}
    218186
  • uspace/app/bdsh/cmds/modules/rm/rm.h

    r90924df rf3378ba  
    22#define RM_H
    33
     4/* Return values for rm_scope() */
     5#define RM_BOGUS 0
     6#define RM_FILE  1
     7#define RM_DIR   2
     8
     9/* Flags for rm_update() */
     10#define _RM_ENTRY   0
     11#define _RM_ADVANCE 1
     12#define _RM_REWIND  2
     13#define _RM_EXIT    3
     14
     15/* A simple job structure */
     16typedef struct {
     17        /* Options set at run time */
     18        unsigned int force;      /* -f option */
     19        unsigned int recursive;  /* -r option */
     20        unsigned int safe;       /* -s option */
     21
     22        /* Keeps track of the job in progress */
     23        int advance; /* How far deep we've gone since entering */
     24        DIR *entry;  /* Entry point to the tree being removed */
     25        char *owd;   /* Where we were when we invoked rm */
     26        char *cwd;   /* Current directory being transversed */
     27        char *nwd;   /* Next directory to be transversed */
     28
     29        /* Counters */
     30        int f_removed; /* Number of files unlinked */
     31        int d_removed; /* Number of directories unlinked */
     32} rm_job_t;
     33
     34
    435/* Prototypes for the rm command, excluding entry points */
     36static unsigned int rm_start(rm_job_t *);
     37static void rm_end(rm_job_t *rm);
     38static unsigned int rm_recursive(const char *);
     39static unsigned int rm_single(const char *);
     40static unsigned int rm_scope(const char *);
    541
    642#endif /* RM_H */
  • uspace/app/bdsh/cmds/modules/sleep/sleep.c

    r90924df rf3378ba  
    2727 */
    2828
    29 #include <errno.h>
    3029#include <stdio.h>
    3130#include <stdlib.h>
    32 #include <unistd.h>
    3331#include "config.h"
    3432#include "util.h"
     
    4341void help_cmd_sleep(unsigned int level)
    4442{
    45         if (level == HELP_SHORT) {
    46                 printf("`%s' pauses for a given time interval\n", cmdname);
    47         } else {
    48                 help_cmd_sleep(HELP_SHORT);
    49                 printf(
    50                     "Usage:  %s <duration>\n"
    51                     "The duration is a decimal number of seconds.\n",
    52                     cmdname);
    53         }
    54 
     43        printf("This is the %s help for '%s'.\n",
     44                level ? EXT_HELP : SHORT_HELP, cmdname);
    5545        return;
    56 }
    57 
    58 /** Convert string containing decimal seconds to useconds_t.
    59  *
    60  * @param nptr   Pointer to string.
    61  * @param result Result of the conversion.
    62  * @return EOK if conversion was successful.
    63  */
    64 static int decimal_to_useconds(const char *nptr, useconds_t *result)
    65 {
    66         int ret;
    67         uint64_t whole_seconds;
    68         uint64_t frac_seconds;
    69         char *endptr;
    70 
    71         /* Check for whole seconds */
    72         if (*nptr == '.') {
    73                 whole_seconds = 0;
    74                 endptr = (char *)nptr;
    75         } else {
    76                 ret = str_uint64_t(nptr, &endptr, 10, false, &whole_seconds);
    77                 if (ret != EOK)
    78                         return ret;
    79         }
    80 
    81         /* Check for fractional seconds */
    82         if (*endptr == '\0') {
    83                 frac_seconds = 0;
    84         } else if (*endptr == '.' && endptr[1] == '\0') {
    85                 frac_seconds = 0;
    86         } else if (*endptr == '.') {
    87                 nptr = endptr + 1;
    88                 ret = str_uint64_t(nptr, &endptr, 10, true, &frac_seconds);
    89                 if (ret != EOK)
    90                         return ret;
    91 
    92                 int ndigits = endptr - nptr;
    93                 for (; ndigits < 6; ndigits++)
    94                         frac_seconds *= 10;
    95                 for (; ndigits > 6; ndigits--)
    96                         frac_seconds /= 10;
    97         } else {
    98                 return EINVAL;
    99         }
    100 
    101         /* Check for overflow */
    102         useconds_t total = whole_seconds * 1000000 + frac_seconds;
    103         if (total / 1000000 != whole_seconds)
    104                 return EOVERFLOW;
    105 
    106         *result = total;
    107 
    108         return EOK;
    10946}
    11047
     
    11249int cmd_sleep(char **argv)
    11350{
    114         int ret;
    11551        unsigned int argc;
    116         useconds_t duration;
     52        unsigned int i;
    11753
    11854        /* Count the arguments */
    119         argc = cli_count_args(argv);
     55        for (argc = 0; argv[argc] != NULL; argc ++);
    12056
    121         if (argc != 2) {
    122                 printf("%s - incorrect number of arguments. Try `help %s'\n",
    123                     cmdname, cmdname);
    124                 return CMD_FAILURE;
     57        printf("%s %s\n", TEST_ANNOUNCE, cmdname);
     58        printf("%d arguments passed to %s", argc - 1, cmdname);
     59
     60        if (argc < 2) {
     61                printf("\n");
     62                return CMD_SUCCESS;
    12563        }
    12664
    127         ret = decimal_to_useconds(argv[1], &duration);
    128         if (ret != EOK) {
    129                 printf("%s - invalid duration.\n", cmdname);
    130                 return CMD_FAILURE;
    131         }
    132 
    133         (void) usleep(duration);
     65        printf(":\n");
     66        for (i = 1; i < argc; i++)
     67                printf("[%d] -> %s\n", i, argv[i]);
    13468
    13569        return CMD_SUCCESS;
  • uspace/lib/c/generic/vfs/vfs.c

    r90924df rf3378ba  
    5858static async_sess_t *vfs_sess = NULL;
    5959
    60 /* Current (working) directory. */
    6160static FIBRIL_MUTEX_INITIALIZE(cwd_mutex);
     61
    6262static int cwd_fd = -1;
    6363static char *cwd_path = NULL;
    6464static size_t cwd_size = 0;
    65 
    66 /* Previous directory. */
    67 static FIBRIL_MUTEX_INITIALIZE(pwd_mutex);
    68 static int pwd_fd = -1;
    69 static char *pwd_path = NULL;
    70 static size_t pwd_size = 0;
    71 
    7265
    7366/** Start an async exchange on the VFS session.
     
    758751        fibril_mutex_lock(&cwd_mutex);
    759752       
    760 
    761         fibril_mutex_lock(&pwd_mutex);
    762 
    763         if (pwd_fd >= 0)
    764                 close(pwd_fd);
    765 
    766 
    767         if (pwd_path)
    768                 free(pwd_path);
    769 
    770 
    771         pwd_fd = cwd_fd;
    772         pwd_path = cwd_path;
    773         pwd_size = cwd_size;
    774 
    775         fibril_mutex_unlock(&pwd_mutex);
    776 
     753        if (cwd_fd >= 0)
     754                close(cwd_fd);
     755       
     756       
     757        if (cwd_path)
     758                free(cwd_path);
     759       
    777760        cwd_fd = fd;
    778761        cwd_path = abs;
     
    798781        fibril_mutex_unlock(&cwd_mutex);
    799782       
    800         return buf;
    801 }
    802 
    803 
    804 char *getprevwd(char *buf, size_t size)
    805 {
    806         if (size == 0)
    807                 return NULL;
    808 
    809         fibril_mutex_lock(&pwd_mutex);
    810 
    811         if ((pwd_size == 0) || (size < pwd_size + 1)) {
    812                 fibril_mutex_unlock(&pwd_mutex);
    813                 return NULL;
    814         }
    815 
    816         str_cpy(buf, size, pwd_path);
    817         fibril_mutex_unlock(&pwd_mutex);
    818 
    819783        return buf;
    820784}
  • uspace/lib/c/include/unistd.h

    r90924df rf3378ba  
    5858#define getpagesize()  (PAGE_SIZE)
    5959
    60 extern int dup2(int, int);
     60extern int dup2(int oldfd, int newfd);
    6161
    6262extern ssize_t write(int, const void *, size_t);
     
    7373extern int unlink(const char *);
    7474
    75 extern char *getcwd(char *, size_t);
    76 extern char *getprevwd(char *, size_t);
     75extern char *getcwd(char *buf, size_t);
    7776extern int rmdir(const char *);
    7877extern int chdir(const char *);
Note: See TracChangeset for help on using the changeset viewer.