Changeset d342f52


Ignore:
Timestamp:
2010-03-15 13:14:38 (4 years ago)
Author:
Poul-Henning Kamp <phk@…>
Branches:
master, 3.0, 4.0, experimental-ims
Children:
773d29a
Parents:
40b0b2
git-author:
Poul-Henning Kamp <phk@…> (2010-03-15 13:14:38)
git-committer:
Poul-Henning Kamp <phk@…> (2010-03-15 13:14:38)
Message:

Simplify the -d Debug mode, by eliminating the very neat and leet
"single -d" mode, which nobody ever used, and make -d do what you expect
it to from all other daemons.

It was a nice idea though.

git-svn-id:  http://www.varnish-cache.org/svn/trunk/varnish-cache@4610 d4fa192b-c00b-0410-8231-f00ffab90ce4

Location:
bin/varnishd
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • bin/varnishd/varnishd.1

    rc08184 rd342f52  
    118118is not specified, the default is 8080. 
    119119.It Fl d 
    120 Enables debugging mode. 
    121 This causes 
    122 .Nm 
    123 to fork; the child process daemonizes and runs as usual, while the 
    124 parent process remains attached to the console and will accept 
    125 management commands from 
    126 .Dv stdin . 
    127 If the parent process receives 
    128 .Dv EOF , 
    129 it will terminate, but the child process will continue to run. 
    130 .Pp 
    131 The child process will not start accepting client connections until 
    132 the 
    133 .Cm start 
    134 command is given. 
    135 .Pp 
    136 If the 
    137 .Fl d 
    138 flag is specified twice, the child process will not daemonize, and 
    139 terminating the parent process will also terminate the child. 
     120Enables debugging mode: 
     121The parent process runs in the foreground with a CLI connection on 
     122stdin/stdout, and the child process must 
     123be started explicitly with a CLI command. 
     124Terminating the parent process will also terminate the child. 
    140125.It Fl F 
    141126Run in the foreground. 
  • bin/varnishd/varnishd.c

    r28dc12 rd342f52  
    278278} 
    279279 
    280 /*-------------------------------------------------------------------- 
    281  * When -d is specified we fork a third process which will relay 
    282  * keystrokes between the terminal and the CLI.  This allows us to 
    283  * detach from the process and have it daemonize properly (ie: it already 
    284  * did that long time ago). 
    285  * Doing the simple thing and calling daemon(3) when the user asks for 
    286  * it does not work, daemon(3) forks and all the threads are lost. 
    287  */ 
    288  
    289 static pid_t d_child; 
    290  
    291  
    292 static void 
    293 DebugSigPass(int sig) 
    294 { 
    295  
    296         (void)kill(d_child, sig); 
    297 } 
    298  
    299 static void 
    300 DebugStunt(void) 
    301 { 
    302         int pipes[2][2]; 
    303         struct pollfd pfd[2]; 
    304         char buf[BUFSIZ]; 
    305         int i, j, k; 
    306         char *p; 
    307  
    308         AZ(pipe(pipes[0])); 
    309         AZ(pipe(pipes[1])); 
    310         d_child = fork(); 
    311         xxxassert(d_child >= 0); 
    312         if (!d_child) { 
    313                 /* stdin from parent, std{out,err} to parent */ 
    314                 assert(dup2(pipes[0][0], 0) == 0); 
    315                 assert(dup2(pipes[1][1], 1) == 1); 
    316                 assert(dup2(pipes[1][1], 2) == 2); 
    317                 AZ(close(pipes[0][0])); 
    318                 AZ(close(pipes[0][1])); 
    319                 AZ(close(pipes[1][0])); 
    320                 AZ(close(pipes[1][1])); 
    321                 return; 
    322         } 
    323  
    324         /* set up parent's end of pipe to child's stdin */ 
    325         AZ(close(pipes[0][0])); 
    326         pipes[0][0] = 0; 
    327         assert(dup2(pipes[0][1], 3) == 3); 
    328         pipes[0][1] = 3; 
    329  
    330         /* set up parent's end of pipe from child's std{out,err} */ 
    331         assert(dup2(pipes[1][0], 4) == 4); 
    332         pipes[1][0] = 4; 
    333         AZ(close(pipes[1][1])); 
    334         pipes[1][1] = 1; 
    335  
    336         /* close the rest */ 
    337         j = getdtablesize(); 
    338         for (i = 5; i < j; i++) 
    339                 (void)close(i); 
    340  
    341         pfd[0].fd = pipes[0][0]; 
    342         pfd[0].events = POLLIN; 
    343         pfd[1].fd = pipes[1][0]; 
    344         pfd[1].events = POLLIN; 
    345  
    346         (void)signal(SIGPIPE, SIG_IGN); 
    347         (void)signal(SIGINT, DebugSigPass); 
    348         i = read(pipes[1][0], buf, sizeof buf - 1); 
    349         xxxassert(i >= 0); 
    350         buf[i] = '\0'; 
    351         d_child = strtoul(buf, &p, 0); 
    352         xxxassert(p != NULL); 
    353         printf("New Pid %ju\n", (uintmax_t)d_child); 
    354         xxxassert(d_child != 0); 
    355         i = strlen(p); 
    356         j = write(pipes[1][1], p, i); 
    357         xxxassert(j == i); 
    358  
    359         while (1) { 
    360                 if (pfd[0].fd == -1 && pfd[1].fd == -1) 
    361                         break; 
    362                 i = poll(pfd, 2, INFTIM); 
    363                 for (k = 0; k < 2; k++) { 
    364                         if (pfd[k].fd == -1) 
    365                                 continue; 
    366                         if (pfd[k].revents == 0) 
    367                                 continue; 
    368                         if (pfd[k].revents != POLLIN) { 
    369                                 printf("k %d rev %d\n", k, pfd[k].revents); 
    370                                 AZ(close(pipes[k][0])); 
    371                                 AZ(close(pipes[k][1])); 
    372                                 pfd[k].fd = -1; 
    373                                 if (k == 1) 
    374                                         exit (0); 
    375                         } 
    376                         j = read(pipes[k][0], buf, sizeof buf); 
    377                         if (j == 0) { 
    378                                 printf("k %d eof\n", k); 
    379                                 AZ(close(pipes[k][0])); 
    380                                 AZ(close(pipes[k][1])); 
    381                                 pfd[k].fd = -1; 
    382                         } 
    383                         if (j > 0) { 
    384                                 i = write(pipes[k][1], buf, j); 
    385                                 if (i != j) { 
    386                                         printf("k %d write (%d %d)\n", k, i, j); 
    387                                         AZ(close(pipes[k][0])); 
    388                                         AZ(close(pipes[k][1])); 
    389                                         pfd[k].fd = -1; 
    390                                 } 
    391                         } 
    392                 } 
    393         } 
    394         exit (0); 
    395 } 
    396  
    397  
    398280/*--------------------------------------------------------------------*/ 
    399281 
     
    509391        assert(open("/dev/null", O_WRONLY) == 2); 
    510392 
    511         if (d_flag == 2) { 
     393        if (d_flag) { 
    512394                mgt_stop_child(); 
    513395                mgt_cli_close_all(); 
     
    781663        AZ(vsb_overflowed(vident)); 
    782664 
    783         if (d_flag == 1) 
    784                 DebugStunt(); 
    785         if (d_flag < 2 && !F_flag) 
    786                 AZ(varnish_daemon(1, d_flag)); 
    787         if (d_flag == 1) 
    788                 printf("%ju\n", (uintmax_t)getpid()); 
     665        if (!d_flag && !F_flag) 
     666                AZ(varnish_daemon(1, 0)); 
    789667 
    790668        if (pfh != NULL && vpf_write(pfh)) 
    791669                fprintf(stderr, "NOTE: Could not write PID file\n"); 
    792670 
    793         if (d_flag > 0) 
     671        if (d_flag) 
    794672                fprintf(stderr, "Varnish on %s\n", vsb_data(vident) + 1); 
    795673 
Note: See TracChangeset for help on using the changeset viewer.