Changeset 1785 for trunk/src


Ignore:
Timestamp:
Sep 14, 2008, 7:31:16 PM (17 years ago)
Author:
bird
Message:

kash: fixed signals. trace all wrapped system calls.

Location:
trunk/src/kash
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kash/Makefile.kmk

    r1784 r1785  
    3535kash_DEFS = lint SHELL SMALL
    3636kash_DEFS += SH_STUB_MODE # for the time being.
    37 kash_DEFS.debug = DEBUG
     37kash_DEFS.debug = DEBUG=2
    3838kash_DEFS.linux = BSD
    3939kash_DEFS.solaris = BSD

  • trunk/src/kash/jobs.c

    r1240 r1785  
    848848                else
    849849                        pgrp = jp->ps[0].pid;
    850                 /* This can fail because we are doing it in the parent also */
     850                /* This can fail because we are doing it in the parent also.
     851                   And we must ignore SIGTTOU at this point or we'll be stopped! */
    851852                (void)sh_setpgid(psh, 0, pgrp);
    852853                if (mode == FORK_FG) {

  • trunk/src/kash/shfile.c

    r1286 r1785  
    2626
    2727#include "shfile.h"
     28#include "shinstance.h" /* TRACE2 */
    2829#include <stdlib.h>
    2930#include <stdio.h>
    … …  
    4344int shfile_open(shfdtab *pfdtab, const char *name, unsigned flags, mode_t mode)
    4445{
    45 #ifdef SH_PURE_STUB_MODE
    46     return -1;
    47 #elif defined(SH_STUB_MODE)
    48     return open(name, flags, mode);
    49 #else
    50 #endif
     46    int fd;
     47
     48#ifdef SH_PURE_STUB_MODE
     49    fd = -1;
     50#elif defined(SH_STUB_MODE)
     51    fd = open(name, flags, mode);
     52#else
     53#endif
     54
     55    TRACE2((NULL, "shfile_open(%p:{%s}, %#x, 0%o) -> %d [%d]\n", name, name, flags, mode, fd, errno));
     56    return fd;
    5157}
    5258
    … …  
    6773int shfile_dup(shfdtab *pfdtab, int fd)
    6874{
    69 #ifdef SH_PURE_STUB_MODE
    70     return -1;
    71 #elif defined(SH_STUB_MODE)
    72     return dup(fd);
    73 #else
    74 #endif
     75    int rc;
     76#ifdef SH_PURE_STUB_MODE
     77    rc = -1;
     78#elif defined(SH_STUB_MODE)
     79    rc = dup(fd);
     80#else
     81#endif
     82
     83    TRACE2((NULL, "shfile_dup(%d) -> %d [%d]\n", fd, rc, errno));
     84    return rc;
    7585}
    7686
    7787int shfile_close(shfdtab *pfdtab, unsigned fd)
    7888{
    79 #ifdef SH_PURE_STUB_MODE
    80     return -1;
    81 #elif defined(SH_STUB_MODE)
    82     return close(fd);
    83 #else
    84 #endif
     89    int rc;
     90
     91#ifdef SH_PURE_STUB_MODE
     92    rc = -1;
     93#elif defined(SH_STUB_MODE)
     94    rc = close(fd);
     95#else
     96#endif
     97
     98    TRACE2((NULL, "shfile_close(%d) -> %d [%d]\n", fd, rc, errno));
     99    return rc;
    85100}
    86101
    … …  
    202217int shfile_isatty(shfdtab *pfdtab, int fd)
    203218{
    204 #ifdef SH_PURE_STUB_MODE
    205     return 0;
    206 #elif defined(SH_STUB_MODE)
    207     return isatty(fd);
    208 #else
    209 #endif
     219    int rc;
     220
     221#ifdef SH_PURE_STUB_MODE
     222    rc = 0;
     223#elif defined(SH_STUB_MODE)
     224    rc = isatty(fd);
     225#else
     226#endif
     227
     228    TRACE2((NULL, "isatty(%d) -> %d [%d]\n", fd, rc, errno));
     229    return rc;
    210230}
    211231
    … …  
    213233int shfile_cloexec(shfdtab *pfdtab, int fd, int closeit)
    214234{
    215 #ifdef SH_PURE_STUB_MODE
    216     return -1;
    217 #elif defined(SH_STUB_MODE)
    218 # ifdef _MSC_VER
    219     return -1;
    220 # else
    221     int rc = fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0)
    222                               | (closeit ? FD_CLOEXEC : 0));
    223     //fprintf(stderr, "shfile_cloexec(%d, %d) -> %d\n", fd, closeit, rc);
    224     return rc;
    225 # endif
    226 #else
    227 #endif
    228 
     235    int rc;
     236
     237#ifdef SH_PURE_STUB_MODE
     238    rc = -1;
     239#elif defined(SH_STUB_MODE)
     240# ifdef _MSC_VER
     241    rc = -1;
     242# else
     243    rc = fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0)
     244                          | (closeit ? FD_CLOEXEC : 0));
     245# endif
     246#else
     247#endif
     248
     249    TRACE2((NULL, "shfile_cloexec(%d, %d) -> %d [%d]\n", fd, closeit, rc, errno));
     250    return rc;
    229251}
    230252
    … …  
    232254int shfile_ioctl(shfdtab *pfdtab, int fd, unsigned long request, void *buf)
    233255{
    234 #ifdef SH_PURE_STUB_MODE
    235     return -1;
    236 #elif defined(SH_STUB_MODE)
    237 # ifdef _MSC_VER
    238     return -1;
    239 # else
    240     int rc = ioctl(fd, request, buf);
    241     //fprintf(stderr, "ioctl(%d, %#x, %p) -> %d\n", fd, request, buf, rc);
    242     return rc;
    243 # endif
    244 #else
    245 #endif
     256    int rc;
     257
     258#ifdef SH_PURE_STUB_MODE
     259    rc = -1;
     260#elif defined(SH_STUB_MODE)
     261# ifdef _MSC_VER
     262    rc = -1;
     263# else
     264    rc = ioctl(fd, request, buf);
     265# endif
     266#else
     267#endif
     268
     269    TRACE2((NULL, "ioctl(%d, %#x, %p) -> %d\n", fd, request, buf, rc));
     270    return rc;
    246271}
    247272

  • trunk/src/kash/shinstance.c

    r1784 r1785  
    320320            g_sig_state[signo].sa = old;
    321321#else
    322             g_sig_state[signo].sa.sa_handle = SIG_DFL;
     322            g_sig_state[signo].sa.sa_handler = SIG_DFL;
    323323            g_sig_state[signo].sa.sa_flags = 0;
    324324            g_sig_state[signo].sa.sa_mask = shold.sh_mask;
    325325#endif
     326            TRACE2((psh, "sh_int_lazy_init_sigaction: signo=%d:%s sa_handler=%p sa_flags=%#x\n",
     327                    signo, sys_signame[signo], g_sig_state[signo].sa.sa_handler, g_sig_state[signo].sa.sa_flags));
    326328
    327329            /* update all shells */
    … …  
    345347static void sh_sig_common_handler(int signo)
    346348{
    347 
     349    fprintf(stderr, "sh_sig_common_handler: signo=%d:%s\n", signo, sys_signame[signo]);
    348350}
    349351
    … …  
    351353int sh_sigaction(shinstance *psh, int signo, const struct shsigaction *newp, struct shsigaction *oldp)
    352354{
    353     printf("sh_sigaction: signo=%d newp=%p oldp=%p\n", signo, newp, oldp);
     355    if (newp)
     356        TRACE2((psh, "sh_sigaction: signo=%d:%s newp=%p:{.sh_handler=%p, .sh_flags=%#x} oldp=%p\n",
     357                signo, sys_signame[signo], newp, newp->sh_handler, newp->sh_flags, oldp));
     358    else
     359        TRACE2((psh, "sh_sigaction: signo=%d:%s newp=NULL oldp=%p\n", signo, sys_signame[signo], oldp));
    354360
    355361    /*
    … …  
    422428            g_sig_state[signo].sa.sa_handler = sh_sig_common_handler;
    423429        else if (g_sig_state[signo].num_ignore)
    424             g_sig_state[signo].sa.sa_handler = SIG_DFL;
     430            g_sig_state[signo].sa.sa_handler = SIG_IGN;
    425431        else
    426432            g_sig_state[signo].sa.sa_handler = SIG_DFL;
    427433        g_sig_state[signo].sa.sa_flags = psh->sigactions[signo].sh_flags & SA_RESTART;
    428434
     435        TRACE2((psh, "sh_sigaction: setting signo=%d:%s to {.sa_handler=%p, .sa_flags=%#x}\n",
     436                    signo, sys_signame[signo], g_sig_state[signo].sa.sa_handler, g_sig_state[signo].sa.sa_flags));
    429437# ifdef _MSC_VER
    430438        if (signal(signo, g_sig_state[signo].sa.sa_handler) == SIG_ERR)
    … …  
    533541void sh_abort(shinstance *psh)
    534542{
    535 #ifdef SH_PURE_STUB_MODE
    536 #elif defined(SH_STUB_MODE)
    537     (void)psh;
     543    TRACE2((psh, "sh_abort\n"));
     544
     545#ifdef SH_PURE_STUB_MODE
     546#elif defined(SH_STUB_MODE)
    538547    abort();
    539548#else
    540549#endif
     550
     551    TRACE2((psh, "sh_abort returns!\n"));
     552    (void)psh;
    541553}
    542554
    543555void sh_raise_sigint(shinstance *psh)
    544556{
     557    TRACE2((psh, "sh_raise(SIGINT)\n"));
     558
    545559#ifdef SH_PURE_STUB_MODE
    546560#elif defined(SH_STUB_MODE)
    … …  
    549563#else
    550564#endif
     565
     566    TRACE2((psh, "sh_raise(SIGINT) returns\n"));
     567    (void)psh;
    551568}
    552569
    553570int sh_kill(shinstance *psh, pid_t pid, int signo)
    554571{
     572    int rc;
     573
     574#ifdef SH_PURE_STUB_MODE
     575    rc = -1;
     576#elif defined(SH_STUB_MODE)
     577# ifdef _MSC_VER
     578    rc = -1;
     579# else
     580    //fprintf(stderr, "kill(%d, %d)\n", pid, signo);
     581    rc = kill(pid, signo);
     582# endif
     583#else
     584#endif
     585
     586    TRACE2((psh, "sh_kill(%d, %d) -> %d [%d]\n", pid, signo, rc, errno));
     587    (void)psh;
     588    return rc;
     589}
     590
     591int sh_killpg(shinstance *psh, pid_t pgid, int signo)
     592{
     593    int rc;
     594
     595#ifdef SH_PURE_STUB_MODE
     596    rc = -1;
     597#elif defined(SH_STUB_MODE)
     598# ifdef _MSC_VER
     599    rc = -1;
     600# else
     601    //fprintf(stderr, "killpg(%d, %d)\n", pgid, signo);
     602    rc = killpg(pgid, signo);
     603# endif
     604#else
     605#endif
     606
     607    TRACE2((psh, "sh_killpg(%d, %d) -> %d [%d]\n", pgid, signo, rc, errno));
     608    (void)psh;
     609    return rc;
     610}
     611
     612clock_t sh_times(shinstance *psh, shtms *tmsp)
     613{
     614#ifdef SH_PURE_STUB_MODE
     615    return 0;
     616#elif defined(SH_STUB_MODE)
     617    (void)psh;
     618# ifdef _MSC_VER
     619    return 0;
     620# else
     621    return times(tmsp);
     622# endif
     623#else
     624#endif
     625}
     626
     627int sh_sysconf_clk_tck(void)
     628{
     629#ifdef SH_PURE_STUB_MODE
     630    return 1;
     631#else
     632# ifdef _MSC_VER
     633    return CLK_TCK;
     634# else
     635    return sysconf(_SC_CLK_TCK);
     636# endif
     637#endif
     638}
     639
     640pid_t sh_fork(shinstance *psh)
     641{
     642    pid_t pid;
     643    TRACE2((psh, "sh_fork\n"));
     644
     645#ifdef SH_PURE_STUB_MODE
     646    pid = -1;
     647#elif defined(SH_STUB_MODE)
     648# ifdef _MSC_VER
     649    pid = -1;
     650# else
     651    pid = fork();
     652# endif
     653#else
     654#endif
     655
     656    TRACE2((psh, "sh_fork -> %d [%d]\n", pid, errno));
     657    (void)psh;
     658    return pid;
     659}
     660
     661pid_t sh_waitpid(shinstance *psh, pid_t pid, int *statusp, int flags)
     662{
     663    pid_t pidret;
     664
     665    *statusp = 0;
     666#ifdef SH_PURE_STUB_MODE
     667    pidret = -1;
     668#elif defined(SH_STUB_MODE)
     669# ifdef _MSC_VER
     670    pidret = -1;
     671# else
     672    pidret = waitpid(pid, statusp, flags);
     673# endif
     674#else
     675#endif
     676
     677    TRACE2((psh, "waitpid(%d, %p, %#x) -> %d [%d] *statusp=%#x (rc=%d)\n", pid, statusp, flags,
     678            pidret, errno, *statusp, WEXITSTATUS(*statusp)));
     679    (void)psh;
     680    return pidret;
     681}
     682
     683void sh__exit(shinstance *psh, int rc)
     684{
     685    TRACE2((psh, "sh__exit(%d)\n", rc));
     686    (void)psh;
     687
    555688#ifdef SH_PURE_STUB_MODE
    556689    return -1;
    557690#elif defined(SH_STUB_MODE)
    558     (void)psh;
    559 # ifdef _MSC_VER
    560     return -1;
    561 # else
    562     //fprintf(stderr, "kill(%d, %d)\n", pid, signo);
    563     return kill(pid, signo);
    564 # endif
    565 #else
    566 #endif
    567 }
    568 
    569 int sh_killpg(shinstance *psh, pid_t pgid, int signo)
    570 {
    571 #ifdef SH_PURE_STUB_MODE
    572     return -1;
    573 #elif defined(SH_STUB_MODE)
    574     (void)psh;
    575 # ifdef _MSC_VER
    576     return -1;
    577 # else
    578     //fprintf(stderr, "killpg(%d, %d)\n", pgid, signo);
    579     return killpg(pgid, signo);
    580 # endif
    581 #else
    582 #endif
    583 }
    584 
    585 clock_t sh_times(shinstance *psh, shtms *tmsp)
    586 {
    587 #ifdef SH_PURE_STUB_MODE
    588     return 0;
    589 #elif defined(SH_STUB_MODE)
    590     (void)psh;
    591 # ifdef _MSC_VER
    592     return 0;
    593 # else
    594     return times(tmsp);
    595 # endif
    596 #else
    597 #endif
    598 }
    599 
    600 int sh_sysconf_clk_tck(void)
    601 {
    602 #ifdef SH_PURE_STUB_MODE
    603     return 1;
    604 #else
    605 # ifdef _MSC_VER
    606     return CLK_TCK;
    607 # else
    608     return sysconf(_SC_CLK_TCK);
    609 # endif
    610 #endif
    611 }
    612 
    613 pid_t sh_fork(shinstance *psh)
    614 {
    615 #ifdef SH_PURE_STUB_MODE
    616     return -1;
    617 #elif defined(SH_STUB_MODE)
    618     (void)psh;
    619 # ifdef _MSC_VER
    620     return -1;
    621 # else
    622     return fork();
    623 # endif
    624 #else
    625 #endif
    626 }
    627 
    628 pid_t sh_waitpid(shinstance *psh, pid_t pid, int *statusp, int flags)
    629 {
    630     *statusp = 0;
    631 #ifdef SH_PURE_STUB_MODE
    632     return -1;
    633 #elif defined(SH_STUB_MODE)
    634     (void)psh;
    635 # ifdef _MSC_VER
    636     return -1;
    637 # else
    638     pid = waitpid(pid, statusp, flags);
    639     //fprintf(stderr, "waitpid -> %d *statusp=%d (rc=%d) flags=%#x\n",  pid, *statusp, WEXITSTATUS(*statusp), flags);
     691    _exit(rc);
     692#else
     693#endif
     694}
     695
     696int sh_execve(shinstance *psh, const char *exe, const char * const *argv, const char * const *envp)
     697{
     698    int rc;
     699
     700#ifdef DEBUG
     701    /* log it all */
     702    TRACE2((psh, "sh_execve(%p:{%s}, %p, %p}\n", exe, exe, argv, envp));
     703    for (rc = 0; argv[rc]; rc++)
     704        TRACE2((psh, "  argv[%d]=%p:{%s}\n", rc, argv[rc], argv[rc]));
     705#endif
     706
     707#ifdef SH_PURE_STUB_MODE
     708    rc = -1;
     709#elif defined(SH_STUB_MODE)
     710# ifdef _MSC_VER
     711    rc = -1;
     712# else
     713    rc = execve(exe, (char **)argv, (char **)envp);
     714# endif
     715#else
     716#endif
     717
     718    TRACE2((psh, "sh_execve -> %d [%d]\n", rc, errno));
     719    (void)psh;
     720    return rc;
     721}
     722
     723uid_t sh_getuid(shinstance *psh)
     724{
     725#ifdef SH_PURE_STUB_MODE
     726    uid_t uid = 0;
     727#elif defined(SH_STUB_MODE)
     728# ifdef _MSC_VER
     729    uid_t uid = 0;
     730# else
     731    uid_t uid = getuid();
     732# endif
     733#else
     734#endif
     735
     736    TRACE2((psh, "sh_getuid() -> %d [%d]\n", uid, errno));
     737    (void)psh;
     738    return uid;
     739}
     740
     741uid_t sh_geteuid(shinstance *psh)
     742{
     743#ifdef SH_PURE_STUB_MODE
     744    uid_t euid = 0;
     745#elif defined(SH_STUB_MODE)
     746# ifdef _MSC_VER
     747    uid_t euid = 0;
     748# else
     749    uid_t euid = geteuid();
     750# endif
     751#else
     752#endif
     753
     754    TRACE2((psh, "sh_geteuid() -> %d [%d]\n", euid, errno));
     755    (void)psh;
     756    return euid;
     757}
     758
     759gid_t sh_getgid(shinstance *psh)
     760{
     761#ifdef SH_PURE_STUB_MODE
     762    gid_t gid = 0;
     763#elif defined(SH_STUB_MODE)
     764# ifdef _MSC_VER
     765    gid_t gid = 0;
     766# else
     767    gid_t gid = getgid();
     768# endif
     769#else
     770#endif
     771
     772    TRACE2((psh, "sh_getgid() -> %d [%d]\n", gid, errno));
     773    (void)psh;
     774    return gid;
     775}
     776
     777gid_t sh_getegid(shinstance *psh)
     778{
     779#ifdef SH_PURE_STUB_MODE
     780    gid_t egid = 0;
     781#elif defined(SH_STUB_MODE)
     782# ifdef _MSC_VER
     783    gid_t egid = 0;
     784# else
     785    gid_t egid = getegid();
     786# endif
     787#else
     788#endif
     789
     790    TRACE2((psh, "sh_getegid() -> %d [%d]\n", egid, errno));
     791    (void)psh;
     792    return egid;
     793}
     794
     795pid_t sh_getpid(shinstance *psh)
     796{
     797    pid_t pid;
     798
     799#ifdef SH_PURE_STUB_MODE
     800    pid = 0;
     801#elif defined(SH_STUB_MODE)
     802# ifdef _MSC_VER
     803    pid = _getpid();
     804# else
     805    pid = getpid();
     806# endif
     807#else
     808#endif
     809
     810    (void)psh;
    640811    return pid;
    641 # endif
    642 #else
    643 #endif
    644 }
    645 
    646 void sh__exit(shinstance *psh, int rc)
    647 {
    648 #ifdef SH_PURE_STUB_MODE
    649     return -1;
    650 #elif defined(SH_STUB_MODE)
    651     (void)psh;
    652     _exit(rc);
    653 #else
    654 #endif
    655 }
    656 
    657 int sh_execve(shinstance *psh, const char *exe, const char * const *argv, const char * const *envp)
    658 {
    659 #ifdef SH_PURE_STUB_MODE
    660     return -1;
    661 #elif defined(SH_STUB_MODE)
    662     (void)psh;
    663 # ifdef _MSC_VER
    664     return -1;
    665 # else
    666     return execve(exe, (char **)argv, (char **)envp);
    667 # endif
    668 #else
    669 #endif
    670 }
    671 
    672 uid_t sh_getuid(shinstance *psh)
    673 {
    674 #ifdef SH_PURE_STUB_MODE
    675     return 0;
    676 #elif defined(SH_STUB_MODE)
    677     (void)psh;
    678 # ifdef _MSC_VER
    679     return 0;
    680 # else
    681     return getuid();
    682 # endif
    683 #else
    684 #endif
    685 }
    686 
    687 uid_t sh_geteuid(shinstance *psh)
    688 {
    689 #ifdef SH_PURE_STUB_MODE
    690     return 0;
    691 #elif defined(SH_STUB_MODE)
    692     (void)psh;
    693 # ifdef _MSC_VER
    694     return 0;
    695 # else
    696     return geteuid();
    697 # endif
    698 #else
    699 #endif
    700 }
    701 
    702 gid_t sh_getgid(shinstance *psh)
    703 {
    704 #ifdef SH_PURE_STUB_MODE
    705     return 0;
    706 #elif defined(SH_STUB_MODE)
    707     (void)psh;
    708 # ifdef _MSC_VER
    709     return 0;
    710 # else
    711     return getgid();
    712 # endif
    713 #else
    714 #endif
    715 }
    716 
    717 gid_t sh_getegid(shinstance *psh)
    718 {
    719 #ifdef SH_PURE_STUB_MODE
    720     return 0;
    721 #elif defined(SH_STUB_MODE)
    722     (void)psh;
    723 # ifdef _MSC_VER
    724     return 0;
    725 # else
    726     return getegid();
    727 # endif
    728 #else
    729 #endif
    730 }
    731 
    732 pid_t sh_getpid(shinstance *psh)
    733 {
    734 #ifdef SH_PURE_STUB_MODE
    735     return 0;
    736 #elif defined(SH_STUB_MODE)
    737     (void)psh;
    738 # ifdef _MSC_VER
    739     return _getpid();
    740 # else
    741     return getpid();
    742 # endif
    743 #else
    744 #endif
    745812}
    746813
    … …  
    748815{
    749816#ifdef SH_PURE_STUB_MODE
    750     return 0;
    751 #elif defined(SH_STUB_MODE)
    752     (void)psh;
    753 # ifdef _MSC_VER
    754     return _getpid();
    755 # else
    756     return getpgrp();
    757 # endif
    758 #else
    759 #endif
     817    pid_t pgrp = 0;
     818#elif defined(SH_STUB_MODE)
     819# ifdef _MSC_VER
     820    pid_t pgrp _getpid();
     821# else
     822    pid_t pgrp = getpgrp();
     823# endif
     824#else
     825#endif
     826
     827    TRACE2((psh, "sh_getpgrp() -> %d [%d]\n", pgrp, errno));
     828    (void)psh;
     829    return pgrp;
    760830}
    761831
    … …  
    763833{
    764834#ifdef SH_PURE_STUB_MODE
    765     return pid;
    766 #elif defined(SH_STUB_MODE)
    767     (void)psh;
    768 # ifdef _MSC_VER
    769     return pid;
    770 # else
    771     return getpgid(pid);
    772 # endif
    773 #else
    774 #endif
     835    pid_t pgid = pid;
     836#elif defined(SH_STUB_MODE)
     837# ifdef _MSC_VER
     838    pid_t pgid = pid;
     839# else
     840    pid_t pgid = getpgid(pid);
     841# endif
     842#else
     843#endif
     844
     845    TRACE2((psh, "sh_getpgid(%d) -> %d [%d]\n", pid, pgid, errno));
     846    (void)psh;
     847    return pgid;
    775848}
    776849
    … …  
    778851{
    779852#ifdef SH_PURE_STUB_MODE
    780     return -1;
    781 #elif defined(SH_STUB_MODE)
    782     (void)psh;
    783 # ifdef _MSC_VER
    784     return -1;
    785 # else
     853    int rc = -1;
     854#elif defined(SH_STUB_MODE)
     855# ifdef _MSC_VER
     856    int rc = -1;
     857# else
     858    int rc = setpgid(pid, pgid);
     859# endif
     860#else
     861#endif
     862
     863    TRACE2((psh, "sh_setpgid(%d, %d) -> %d [%d]\n", pid, pgid, rc, errno));
     864    (void)psh;
     865    return rc;
     866}
     867
     868pid_t sh_tcgetpgrp(shinstance *psh, int fd)
     869{
     870    pid_t pgrp;
     871
     872#ifdef SH_PURE_STUB_MODE
     873    pgrp = -1;
     874#elif defined(SH_STUB_MODE)
     875# ifdef _MSC_VER
     876    pgrp = -1;
     877# else
     878    pgrp = tcgetpgrp(fd);
     879# endif
     880#else
     881#endif
     882
     883    TRACE2((psh, "sh_tcgetpgrp(%d) -> %d [%d]\n", fd, pgrp, errno));
     884    (void)psh;
     885    return pgrp;
     886}
     887
     888int sh_tcsetpgrp(shinstance *psh, int fd, pid_t pgrp)
     889{
    786890    int rc;
    787     rc = setpgid(pid, pgid);
    788     //fprintf(stderr, "setpgid(%d,%d) -> %d\n",  pid, pgid, rc);
     891    TRACE2((psh, "sh_tcsetpgrp(%d, %d)\n", fd, pgrp));
     892
     893#ifdef SH_PURE_STUB_MODE
     894    rc = -1;
     895#elif defined(SH_STUB_MODE)
     896# ifdef _MSC_VER
     897    rc = -1;
     898# else
     899    rc = tcsetpgrp(fd, pgrp);
     900# endif
     901#else
     902#endif
     903
     904    TRACE2((psh, "sh_tcsetpgrp(%d, %d) -> %d [%d]\n", fd, pgrp, rc, errno));
     905    (void)psh;
    789906    return rc;
    790 # endif
    791 #else
    792 #endif
    793 }
    794 
    795 pid_t sh_tcgetpgrp(shinstance *psh, int fd)
    796 {
    797 #ifdef SH_PURE_STUB_MODE
    798     return -1;
    799 #elif defined(SH_STUB_MODE)
    800     (void)psh;
    801 # ifdef _MSC_VER
    802     return -1;
    803 # else
    804     return tcgetpgrp(fd);
    805 # endif
    806 #else
    807 #endif
    808 }
    809 
    810 int sh_tcsetpgrp(shinstance *psh, int fd, pid_t pgrp)
    811 {
    812 #ifdef SH_PURE_STUB_MODE
    813     return -1;
    814 #elif defined(SH_STUB_MODE)
    815     (void)psh;
    816 # ifdef _MSC_VER
    817     return -1;
    818 # else
    819     return tcsetpgrp(fd, pgrp);
    820 # endif
    821 #else
    822 #endif
    823907}
    824908
    … …  
    826910{
    827911#ifdef SH_PURE_STUB_MODE
    828     return -1;
    829 #elif defined(SH_STUB_MODE)
    830     (void)psh;
    831 # ifdef _MSC_VER
    832     return -1;
    833 # else
    834     return getrlimit(resid, limp);
    835 # endif
    836 #else
    837 #endif
     912    int rc = -1;
     913#elif defined(SH_STUB_MODE)
     914# ifdef _MSC_VER
     915    int rc = -1;
     916# else
     917    int rc = getrlimit(resid, limp);
     918# endif
     919#else
     920#endif
     921
     922    TRACE2((psh, "sh_getrlimit(%d, %p) -> %d [%d] {%ld,%ld}\n",
     923            resid, limp, rc, errno, (long)limp->rlim_cur, (long)limp->rlim_max));
     924    (void)psh;
     925    return rc;
    838926}
    839927
    … …  
    841929{
    842930#ifdef SH_PURE_STUB_MODE
    843     return -1;
    844 #elif defined(SH_STUB_MODE)
    845     (void)psh;
    846 # ifdef _MSC_VER
    847     return -1;
    848 # else
    849     return setrlimit(resid, limp);
    850 # endif
    851 #else
    852 #endif
    853 }
    854 
     931    int rc = -1;
     932#elif defined(SH_STUB_MODE)
     933# ifdef _MSC_VER
     934    int rc = -1;
     935# else
     936    int rc = setrlimit(resid, limp);
     937# endif
     938#else
     939#endif
     940
     941    TRACE2((psh, "sh_setrlimit(%d, %p:{%ld,%ld}) -> %d [%d]\n",
     942            resid, limp, (long)limp->rlim_cur, (long)limp->rlim_max, rc, errno));
     943    (void)psh;
     944    return rc;
     945}
     946

  • trunk/src/kash/shinstance.h

    r1784 r1785  
    5050#include "exec.h"
    5151#include "var.h"
     52#include "show.h"
    5253
    5354#ifdef _MSC_VER
    … …  
    457458int sh_setrlimit(shinstance *, int, const shrlimit *);
    458459
    459 #endif
     460
     461#ifdef DEBUG
     462# define TRACE2(param)  trace param
     463# define TRACE2V(param) tracev param
     464#else
     465# define TRACE2(param)
     466# define TRACE2V(param)
     467#endif
     468
     469#endif

  • trunk/src/kash/show.c

    r1233 r1785  
    284284{
    285285#ifdef DEBUG
     286        int savederrno = errno;
    286287        va_list va;
    287288
    288         if (debug(psh) != 1)
     289        if ((psh || !tracefile) && debug(psh) != 1)
    289290                return;
    290291        fprintf(tracefile, "[%d] ", sh_getpid(psh));
    … …  
    292293        (void) vfprintf(tracefile, fmt, va);
    293294        va_end(va);
     295
     296        errno = savederrno;
    294297#endif
    295298}
    … …  
    299302{
    300303#ifdef DEBUG
    301         if (debug(psh) != 1)
     304        int savederrno = errno;
     305
     306        if ((psh || !tracefile) && debug(psh) != 1)
    302307                return;
    303308        fprintf(tracefile, "[%d] ", sh_getpid(psh));
    304309        (void) vfprintf(tracefile, fmt, va);
     310
     311        errno = savederrno;
    305312#endif
    306313}
    … …  
    311318trputs(shinstance *psh, const char *s)
    312319{
    313         if (debug(psh) != 1)
     320        int savederrno = errno;
     321
     322        if ((psh || !tracefile) && debug(psh) != 1)
    314323                return;
    315324        fputs(s, tracefile);
     325
     326        errno = savederrno;
    316327}
    317328
    … …  
    320331trstring(shinstance *psh, char *s)
    321332{
     333        int savederrno = errno;
    322334        char *p;
    323335        char c;
    324336
    325         if (debug(psh) != 1)
     337        if ((psh || !tracefile) && debug(psh) != 1)
    326338                return;
    327339        putc('"', tracefile);
    … …  
    354366        }
    355367        putc('"', tracefile);
     368
     369        errno = savederrno;
    356370}
    357371#endif
    … …  
    362376{
    363377#ifdef DEBUG
    364         if (debug(psh) != 1)
     378        int savederrno = errno;
     379
     380        if ((psh || !tracefile) && debug(psh) != 1)
    365381                return;
    366382        while (*ap) {
    … …  
    371387                        putc('\n', tracefile);
    372388        }
     389
     390        errno = savederrno;
    373391#endif
    374392}
Note: See TracChangeset for help on using the changeset viewer.