Changes in / [51e5608:b330b309] in mainline


Ignore:
Files:
3 added
27 edited

Legend:

Unmodified
Added
Removed
  • HelenOS.config

    r51e5608 rb330b309  
    417417! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=keyboard)&PLATFORM=ia64&MACHINE=i460GX] CONFIG_PC_KBD (y/n)
    418418
    419 % PC keyboard support
    420 ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=keyboard)&PLATFORM=arm32&MACHINE=integratorcp] CONFIG_PC_KBD (y/n)
    421 
    422419% Support for msim/GXemul keyboard
    423420! [CONFIG_HID_IN=generic&PLATFORM=mips32] CONFIG_MIPS_KBD (y/n)
  • kernel/arch/arm32/src/mach/integratorcp/integratorcp.c

    r51e5608 rb330b309  
    292292                .y = 480,
    293293                .scan = 2560,
    294                 .visual = VISUAL_RGB_8_8_8_0,
     294                .visual = VISUAL_BGR_0_8_8_8,
    295295        };
    296296       
  • kernel/arch/mips32/include/cp0.h

    r51e5608 rb330b309  
    7070  { \
    7171      uint32_t retval; \
    72       asm volatile ("mfc0 %0, $" #reg : "=r"(retval)); \
     72      asm("mfc0 %0, $" #reg : "=r"(retval)); \
    7373      return retval; \
    7474  }
     
    7676#define GEN_WRITE_CP0(nm,reg) static inline void cp0_ ##nm##_write(uint32_t val) \
    7777 { \
    78     asm volatile ("mtc0 %0, $" #reg : : "r"(val) ); \
     78    asm("mtc0 %0, $" #reg : : "r"(val) ); \
    7979 }
    8080
  • kernel/arch/sparc64/src/smp/sun4v/smp.c

    r51e5608 rb330b309  
    11/*
    22 * Copyright (c) 2006 Jakub Jermar
    3  * Copyright (c) 2009 Pavel Rimsky
     3 * Copyright (c) 2009 Pavel Rimsky 
    44 * All rights reserved.
    55 *
     
    439439        if (waitq_sleep_timeout(&ap_completion_wq, 10000000, SYNCH_FLAGS_NONE) ==
    440440            ESYNCH_TIMEOUT)
    441                 printf("%s: waiting for processor (cpuid = %" PRIu64 ") timed out\n",
     441                printf("%s: waiting for processor (cpuid = %" PRIu32 ") timed out\n",
    442442                    __func__, cpuid);
    443443       
  • kernel/arch/sparc64/src/sun4v/start.S

    r51e5608 rb330b309  
    296296         * Create the first stack frame.
    297297         */
    298         save %sp, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp
     298        save %sp, -(STACK_WINDWO_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp
    299299        flushw
    300300        add %g0, -STACK_BIAS, %fp
  • kernel/arch/sparc64/src/trap/sun4v/interrupt.c

    r51e5608 rb330b309  
    111111                        ((void (*)(void)) data1)();
    112112                } else {
    113                         printf("Spurious interrupt on %" PRIu64 ", data = %" PRIx64 ".\n",
     113                        printf("Spurious interrupt on %d, data = %" PRIx64 ".\n",
    114114                            CPU->arch.id, data1);
    115115                }
  • kernel/genarch/Makefile.inc

    r51e5608 rb330b309  
    122122endif
    123123
     124ifeq ($(CONFIG_PL050),y)
     125        GENARCH_SOURCES += \
     126                genarch/src/kbrd/kbrd_pl050.c \
     127                genarch/src/kbrd/scanc_pl050.c
     128endif
     129
    124130ifeq ($(CONFIG_MAC_KBD),y)
    125131        GENARCH_SOURCES += \
  • uspace/app/bdsh/cmds/modules/cat/cat.c

    r51e5608 rb330b309  
    11/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
    2  * Copyright (c) 2011, Martin Sucha
    32 * All rights reserved.
    43 *
     
    3635#include <str.h>
    3736#include <fcntl.h>
    38 #include <io/console.h>
    39 #include <io/color.h>
    40 #include <io/style.h>
    41 #include <io/keycode.h>
    42 #include <errno.h>
    43 #include <vfs/vfs.h>
    44 #include <assert.h>
    4537
    4638#include "config.h"
     
    5648
    5749static const char *cat_oops = "That option is not yet supported\n";
    58 static const char *hexchars = "0123456789abcdef";
    59 
    60 static bool paging_enabled = false;
    61 static size_t chars_remaining = 0;
    62 static size_t lines_remaining = 0;
    63 static sysarg_t console_cols = 0;
    64 static sysarg_t console_rows = 0;
    65 static bool should_quit = false;
    6650
    6751static struct option const long_options[] = {
     
    7256        { "buffer", required_argument, 0, 'b' },
    7357        { "more", no_argument, 0, 'm' },
    74         { "hex", no_argument, 0, 'x' },
    7558        { 0, 0, 0, 0 }
    7659};
     
    9275                "  -b, --buffer ##  Set the read buffer size to ##\n"
    9376                "  -m, --more       Pause after each screen full\n"
    94                 "  -x, --hex        Print bytes as hex values\n"
    9577                "Currently, %s is under development, some options don't work.\n",
    9678                cmdname, cmdname);
     
    10082}
    10183
    102 static void waitprompt()
    103 {
    104         console_set_pos(fphone(stdout), 0, console_rows-1);
    105         console_set_color(fphone(stdout), COLOR_BLUE, COLOR_WHITE, 0);
    106         printf("ENTER/SPACE/PAGE DOWN - next page, "
    107                "ESC/Q - quit, C - continue unpaged");
    108         fflush(stdout);
    109         console_set_style(fphone(stdout), STYLE_NORMAL);
    110 }
    111 
    112 static void waitkey()
    113 {
    114         console_event_t ev;
    115        
    116         while (true) {
    117                 if (!console_get_event(fphone(stdin), &ev)) {
    118                         return;
    119                 }
    120                 if (ev.type == KEY_PRESS) {
    121                         if (ev.key == KC_ESCAPE || ev.key == KC_Q) {
    122                                 should_quit = true;
    123                                 return;
    124                         }
    125                         if (ev.key == KC_C) {
    126                                 paging_enabled = false;
    127                                 return;
    128                         }
    129                         if (ev.key == KC_ENTER || ev.key == KC_SPACE ||
    130                             ev.key == KC_PAGE_DOWN) {
    131                                 return;
    132                         }
    133                 }
    134         }
    135         assert(false);
    136 }
    137 
    138 static void newpage()
    139 {
    140         console_clear(fphone(stdout));
    141         chars_remaining = console_cols;
    142         lines_remaining = console_rows-1;
    143 }
    144 
    145 static void paged_char(wchar_t c)
    146 {
    147         putchar(c);
    148         if (paging_enabled) {
    149                 chars_remaining--;
    150                 if (c == '\n' || chars_remaining == 0) {
    151                         chars_remaining = console_cols;
    152                         lines_remaining--;
    153                 }
    154                 if (lines_remaining == 0) {
    155                         fflush(stdout);
    156                         waitprompt();
    157                         waitkey();
    158                         newpage();
    159                 }
    160         }
    161 }
    162 
    163 static unsigned int cat_file(const char *fname, size_t blen, bool hex)
     84static unsigned int cat_file(const char *fname, size_t blen)
    16485{
    16586        int fd, bytes = 0, count = 0, reads = 0;
    16687        off64_t total = 0;
    16788        char *buff = NULL;
    168         int i;
    169         size_t offset = 0;
    17089
    17190        fd = open(fname, O_RDONLY);
     
    190109                        count += bytes;
    191110                        buff[bytes] = '\0';
    192                         offset = 0;
    193                         for (i = 0; i < bytes && !should_quit; i++) {
    194                                 if (hex) {
    195                                         paged_char(hexchars[((uint8_t)buff[i])/16]);
    196                                         paged_char(hexchars[((uint8_t)buff[i])%16]);
    197                                 }
    198                                 else {
    199                                         wchar_t c = str_decode(buff, &offset, bytes);
    200                                         if (c == 0) {
    201                                                 // reached end of string
    202                                                 break;
    203                                         }
    204                                         paged_char(c);
    205                                 }
    206                                
    207                         }
     111                        printf("%s", buff);
    208112                        reads++;
    209113                }
    210         } while (bytes > 0 && !should_quit);
     114        } while (bytes > 0);
    211115
    212116        close(fd);
     
    227131        unsigned int argc, i, ret = 0, buffer = 0;
    228132        int c, opt_ind;
    229         bool hex = false;
    230         bool more = false;
    231         sysarg_t rows, cols;
    232         int rc;
    233        
    234         // reset global state
    235         // TODO: move to structure?
    236         paging_enabled = false;
    237         chars_remaining = 0;
    238         lines_remaining = 0;
    239         console_cols = 0;
    240         console_rows = 0;
    241         should_quit = false;
    242133
    243134        argc = cli_count_args(argv);
    244135
    245136        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    246                 c = getopt_long(argc, argv, "xhvmH:t:b:", long_options, &opt_ind);
     137                c = getopt_long(argc, argv, "hvmH:t:b:", long_options, &opt_ind);
    247138                switch (c) {
    248139                case 'h':
     
    262153                        break;
    263154                case 'm':
    264                         more = true;
    265                         break;
    266                 case 'x':
    267                         hex = true;
    268                         break;
     155                        printf("%s", cat_oops);
     156                        return CMD_FAILURE;
    269157                }
    270158        }
     
    280168        if (buffer <= 0)
    281169                buffer = CAT_DEFAULT_BUFLEN;
    282        
    283         if (more) {
    284                 rc = console_get_size(fphone(stdout), &cols, &rows);
    285                 if (rc != EOK) {
    286                         printf("%s - cannot get console size\n", cmdname);
    287                         return CMD_FAILURE;
    288                 }
    289                 console_cols = cols;
    290                 console_rows = rows;
    291                 paging_enabled = true;
    292                 newpage();
    293         }
    294170
    295         for (i = optind; argv[i] != NULL && !should_quit; i++)
    296                 ret += cat_file(argv[i], buffer, hex);
     171        for (i = optind; argv[i] != NULL; i++)
     172                ret += cat_file(argv[i], buffer);
    297173
    298174        if (ret)
  • uspace/app/bdsh/cmds/modules/cat/cat.h

    r51e5608 rb330b309  
    44/* Prototypes for the cat command, excluding entry points */
    55
    6 static unsigned int cat_file(const char *, size_t, bool);
     6static unsigned int cat_file(const char *, size_t);
    77
    88#endif /* CAT_H */
  • uspace/app/bdsh/cmds/modules/cp/cp.c

    r51e5608 rb330b309  
    108108        for (;;) {
    109109                ssize_t res;
    110                 size_t written = 0;
    111110
    112111                bytes = read(fd1, buff, blen);
     
    121120                         * returned less data than requested.
    122121                         */
    123                         bytes = write(fd2, buff + written, res);
     122                        bytes = write(fd2, buff, res);
    124123                        if (bytes < 0)
    125124                                goto err;
    126                         written += bytes;
    127125                        res -= bytes;
    128126                } while (res > 0);
  • uspace/app/bdsh/cmds/modules/rm/rm.c

    r51e5608 rb330b309  
    101101}
    102102
    103 static unsigned int rm_recursive_not_empty_dirs(const char *path)
    104 {
    105         DIR *dirp;
    106         struct dirent *dp;
    107         char buff[PATH_MAX];
    108         unsigned int scope;
    109         unsigned int ret = 0;
    110 
    111         dirp = opendir(path);
    112         if (!dirp) {
    113                 /* May have been deleted between scoping it and opening it */
    114                 cli_error(CL_EFAIL, "Could not open %s", path);
    115                 return ret;
    116         }
    117 
    118         memset(buff, 0, sizeof(buff));
    119         while ((dp = readdir(dirp))) {
    120                 snprintf(buff, PATH_MAX - 1, "%s/%s", path, dp->d_name);
    121                 scope = rm_scope(buff);
    122                 switch (scope) {
    123                 case RM_BOGUS:
    124                         break;
    125                 case RM_FILE:
    126                         ret += rm_single(buff);
    127                         break;
    128                 case RM_DIR:
    129                         ret += rm_recursive(buff);
    130                         break;
    131                 }
    132         }
    133        
    134         return ret;
    135 }
    136 
    137103static unsigned int rm_recursive(const char *path)
    138104{
    139105        int rc;
    140         unsigned int ret = 0;
    141106
    142107        /* First see if it will just go away */
     
    146111
    147112        /* Its not empty, recursively scan it */
    148         ret = rm_recursive_not_empty_dirs(path);
    149 
    150         /* Delete directory */
    151         rc = rmdir(path);
    152         if (rc == 0)
    153                 return ret;
    154 
    155         cli_error(CL_ENOTSUP, "Can not remove %s", path);
    156 
    157         return ret + 1;
     113        cli_error(CL_ENOTSUP,
     114                "Can not remove %s, directory not empty", path);
     115        return 1;
    158116}
    159117
  • uspace/drv/pciintel/pci.c

    r51e5608 rb330b309  
    9595        sysarg_t i8259;
    9696
    97         int irc_phone = ENOTSUP;
    98 
    99         if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
    100             || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) {
    101                 irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
    102         }
    103 
     97        int irc_phone = -1;
     98        int irc_service = -1;
     99
     100        if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) {
     101                irc_service = SERVICE_APIC;
     102        } else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) {
     103                irc_service = SERVICE_I8259;
     104        }
     105
     106        if (irc_service == -1) {
     107                return false;
     108        }
     109
     110        irc_phone = service_connect_blocking(irc_service, 0, 0);
    104111        if (irc_phone < 0) {
    105112                return false;
  • uspace/lib/c/include/ipc/services.h

    r51e5608 rb330b309  
    4747        SERVICE_DEVMAP,
    4848        SERVICE_DEVMAN,
    49         SERVICE_IRC,
     49        SERVICE_FHC,
     50        SERVICE_OBIO,
     51        SERVICE_APIC,
     52        SERVICE_I8259,
    5053        SERVICE_CLIPBOARD,
    5154        SERVICE_NETWORKING,
  • uspace/lib/fs/libfs.c

    r51e5608 rb330b309  
    391391                                                if (lflag & L_CREATE)
    392392                                                        (void) ops->destroy(fn);
    393                                                 else
    394                                                         (void) ops->node_put(fn);
    395393                                                async_answer_0(rid, rc);
    396394                                        } else {
     
    475473                                        if (lflag & L_CREATE)
    476474                                                (void) ops->destroy(fn);
    477                                         else
    478                                                 (void) ops->node_put(fn);
    479475                                        async_answer_0(rid, rc);
    480476                                } else {
  • uspace/srv/hid/kbd/Makefile

    r51e5608 rb330b309  
    7878                SOURCES += \
    7979                        port/pl050.c \
    80                         ctl/pc.c
     80                        ctl/pl050.c
    8181        endif
    8282endif
  • uspace/srv/hid/kbd/generic/kbd.c

    r51e5608 rb330b309  
    6767static unsigned lock_keys;
    6868
    69 bool irc_service = false;
    70 int irc_phone = -1;
     69int cir_service = 0;
     70int cir_phone = -1;
    7171
    7272#define NUM_LAYOUTS 3
     
    216216        sysarg_t obio;
    217217       
    218         if (((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
    219             || ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio)))
    220                 irc_service = true;
    221        
    222         if (irc_service) {
    223                 while (irc_phone < 0)
    224                         irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
     218        if ((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
     219                cir_service = SERVICE_FHC;
     220        else if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
     221                cir_service = SERVICE_OBIO;
     222       
     223        if (cir_service) {
     224                while (cir_phone < 0)
     225                        cir_phone = service_connect_blocking(cir_service, 0, 0);
    225226        }
    226227       
  • uspace/srv/hid/kbd/include/kbd.h

    r51e5608 rb330b309  
    3838#define KBD_KBD_H_
    3939
    40 #include <bool.h>
    41 
    42 extern bool irc_service;
    43 extern int irc_phone;
     40extern int cir_service;
     41extern int cir_phone;
    4442
    4543extern void kbd_push_scancode(int);
  • uspace/srv/hid/kbd/port/ns16550.c

    r51e5608 rb330b309  
    120120        kbd_push_scancode(scan_code);
    121121       
    122         if (irc_service)
    123                 async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT,
     122        if (cir_service)
     123                async_msg_1(cir_phone, IRC_CLEAR_INTERRUPT,
    124124                    IPC_GET_IMETHOD(*call));
    125125}
  • uspace/srv/hid/kbd/port/z8530.c

    r51e5608 rb330b309  
    108108        kbd_push_scancode(scan_code);
    109109       
    110         if (irc_service)
    111                 async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT,
     110        if (cir_service)
     111                async_msg_1(cir_phone, IRC_CLEAR_INTERRUPT,
    112112                    IPC_GET_IMETHOD(*call));
    113113}
  • uspace/srv/hw/irc/apic/apic.c

    r51e5608 rb330b309  
    5454#define NAME  "apic"
    5555
     56static bool apic_found = false;
     57
    5658static int apic_enable_irq(sysarg_t irq)
    5759{
     
    7981                callid = async_get_call(&call);
    8082               
    81                 switch (IPC_GET_IMETHOD(call)) {
     83                sysarg_t method = IPC_GET_IMETHOD(call);
     84                if (method == IPC_M_PHONE_HUNGUP) {
     85                        return;
     86                }
     87
     88                if (!apic_found) {
     89                        async_answer_0(callid, ENOTSUP);
     90                        break;
     91                }
     92
     93                switch (method) {
    8294                case IRC_ENABLE_INTERRUPT:
    8395                        async_answer_0(callid, apic_enable_irq(IPC_GET_ARG1(call)));
     
    97109 *
    98110 */
    99 static bool apic_init(void)
     111static void apic_init(void)
    100112{
    101113        sysarg_t apic;
    102114       
    103         if ((sysinfo_get_value("apic", &apic) != EOK) || (!apic)) {
    104                 printf(NAME ": No APIC found\n");
    105                 return false;
     115        apic_found = sysinfo_get_value("apic", &apic) && apic;
     116        if (!apic_found) {
     117                printf(NAME ": Warning: no APIC found\n");
    106118        }
    107119       
    108120        async_set_client_connection(apic_connection);
    109         service_register(SERVICE_IRC);
    110        
    111         return true;
     121        service_register(SERVICE_APIC);
    112122}
    113123
     
    116126        printf(NAME ": HelenOS APIC driver\n");
    117127       
    118         if (!apic_init())
    119                 return -1;
    120        
     128        apic_init();
     129
    121130        printf(NAME ": Accepting connections\n");
    122131        async_manager();
  • uspace/srv/hw/irc/fhc/fhc.c

    r51e5608 rb330b309  
    136136       
    137137        async_set_client_connection(fhc_connection);
    138         service_register(SERVICE_IRC);
     138        service_register(SERVICE_FHC);
    139139       
    140140        return true;
  • uspace/srv/hw/irc/i8259/i8259.c

    r51e5608 rb330b309  
    149149       
    150150        async_set_client_connection(i8259_connection);
    151         service_register(SERVICE_IRC);
     151        service_register(SERVICE_I8259);
    152152       
    153153        return true;
  • uspace/srv/hw/irc/obio/obio.c

    r51e5608 rb330b309  
    137137       
    138138        async_set_client_connection(obio_connection);
    139         service_register(SERVICE_IRC);
     139        service_register(SERVICE_OBIO);
    140140       
    141141        return true;
  • uspace/srv/hw/netif/ne2000/ne2000.c

    r51e5608 rb330b309  
    7575#define IRQ_GET_TSR(call)  ((int) IPC_GET_ARG3(call))
    7676
    77 static bool irc_service = false;
     77static int irc_service = 0;
    7878static int irc_phone = -1;
    7979
     
    383383        sysarg_t i8259;
    384384       
    385         if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
    386             || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)))
    387                 irc_service = true;
     385        if ((sysinfo_get_value("apic", &apic) == EOK) && (apic))
     386                irc_service = SERVICE_APIC;
     387        else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))
     388                irc_service = SERVICE_I8259;
    388389       
    389390        if (irc_service) {
    390391                while (irc_phone < 0)
    391                         irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
     392                        irc_phone = service_connect_blocking(irc_service, 0, 0);
    392393        }
    393394       
  • uspace/srv/net/net/net.c

    r51e5608 rb330b309  
    289289        if (rc != EOK)
    290290                return rc;
    291        
    292291        rc = add_module(NULL, &net_globals.modules, (uint8_t *) NE2000_NAME,
    293292            (uint8_t *) NE2000_FILENAME, SERVICE_NE2000, 0, connect_to_service);
    294293        if (rc != EOK)
    295294                return rc;
    296        
    297295        rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME,
    298296            (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
    299297        if (rc != EOK)
    300298                return rc;
    301        
    302299        rc = add_module(NULL, &net_globals.modules, (uint8_t *) NILDUMMY_NAME,
    303300            (uint8_t *) NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
     
    593590                rc = start_device(netif);
    594591                if (rc != EOK) {
    595                         printf("%s: Ignoring failed interface %s (%s)\n", NAME,
     592                        printf("%s: Error starting interface %s (%s)\n", NAME,
    596593                            netif->name, str_error(rc));
    597594                        measured_strings_destroy(&netif->configuration);
    598595                        netifs_exclude_index(&net_globals.netifs, index);
    599                         continue;
     596                       
     597                        return rc;
    600598                }
    601599               
  • uspace/srv/vfs/vfs_ops.c

    r51e5608 rb330b309  
    12341234        if (!parentc) {
    12351235                fibril_rwlock_write_unlock(&namespace_rwlock);
    1236                 vfs_node_put(old_node);
    12371236                async_answer_0(rid, rc);
    12381237                free(old);
     
    12521251        if (rc != EOK) {
    12531252                fibril_rwlock_write_unlock(&namespace_rwlock);
    1254                 vfs_node_put(old_node);
    12551253                async_answer_0(rid, rc);
    12561254                free(old);
     
    12631261            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    12641262                fibril_rwlock_write_unlock(&namespace_rwlock);
    1265                 vfs_node_put(old_node);
    12661263                async_answer_0(rid, EXDEV);     /* different file systems */
    12671264                free(old);
     
    12821279                if (!new_node) {
    12831280                        fibril_rwlock_write_unlock(&namespace_rwlock);
    1284                         vfs_node_put(old_node);
    12851281                        async_answer_0(rid, ENOMEM);
    12861282                        free(old);
     
    12941290        default:
    12951291                fibril_rwlock_write_unlock(&namespace_rwlock);
    1296                 vfs_node_put(old_node);
    12971292                async_answer_0(rid, ENOTEMPTY);
    12981293                free(old);
     
    13051300        if (rc != EOK) {
    13061301                fibril_rwlock_write_unlock(&namespace_rwlock);
    1307                 vfs_node_put(old_node);
    13081302                if (new_node)
    13091303                        vfs_node_put(new_node);
  • version

    r51e5608 rb330b309  
    3737VERSION = 0
    3838PATCHLEVEL = 4
    39 SUBLEVEL = 3
     39SUBLEVEL = 2
    4040
    4141ifdef EXTRAVERSION
     
    4545endif
    4646
    47 NAME = Sashimi
     47NAME = Skewer
Note: See TracChangeset for help on using the changeset viewer.