git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/status.c

   1 /*
   2  *  Bacula File Daemon Status routines
   3  *
   4  *    Kern Sibbald, August MMI
   5  *
   6  *   Version $Id$
   7  *
   8  */
   9 /*
  10    Copyright (C) 2000-2004 Kern Sibbald and John Walker
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation; either version 2 of
  15    the License, or (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public
  23    License along with this program; if not, write to the Free
  24    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25    MA 02111-1307, USA.
  26
  27  */
  28
  29 #include "bacula.h"
  30 #include "filed.h"
  31
  32 extern char my_name[];
  33 extern int num_jobs_run;
  34 extern time_t daemon_start_time;
  35 extern bool get_trace(void);
  36
  37 /* Forward referenced functions */
  38 static void  list_terminated_jobs(void sendit(const char *msg, int len, void *sarg), void *arg);
  39 static void bsock_sendit(const char *msg, int len, void *arg);
  40 static const char *level_to_str(int level);
  41
  42 /* Static variables */
  43 static char qstatus[] = ".status %s\n";
  44
  45 static char OKqstatus[]   = "2000 OK .status\n";
  46 static char DotStatusJob[] = "JobId=%d JobStatus=%c JobErrors=%d\n";
  47
  48 #if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
  49 static int privs = 0;
  50 #endif
  51
  52 /*
  53  * General status generator
  54  */
  55 static void do_status(void sendit(const char *msg, int len, void *sarg), void *arg)
  56 {
  57    int sec, bps;
  58    char *msg, b1[32], b2[32], b3[32], b4[32];
  59    int found, len;
  60    JCR *njcr;
  61    char dt[MAX_TIME_LENGTH];
  62
  63    msg = (char *)get_pool_memory(PM_MESSAGE);
  64    found = 0;
  65    len = Mmsg(msg, "%s Version: " VERSION " (" BDATE ") %s %s %s\n", my_name,
  66               HOST_OS, DISTNAME, DISTVER);
  67    sendit(msg, len, arg);
  68    bstrftime_nc(dt, sizeof(dt), daemon_start_time);
  69    len = Mmsg(msg, _("Daemon started %s, %d Job%s run since started.\n"),
  70         dt, num_jobs_run, num_jobs_run == 1 ? "" : "s");
  71    sendit(msg, len, arg);
  72 #if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
  73    if (/*debug_level > 0*/ true) {
  74       if (!privs) {
  75          privs = enable_backup_privileges(NULL, 1);
  76       }
  77       len = Mmsg(msg,
  78      _(" Priv 0x%x\n APIs=%sOPT,%sATP,%sLPV,%sCFA,%sCFW,\n"
  79      " %sWUL,%sWMKD,%sWOP,%sGFAA,%sGFAW,%sGFAEA,%sGFAEW,%sSFAA,%sSFAW,%sBR,%sBW,%sSPSP,\n"
  80      " %sWC2MB,%sMB2WC,%sFFFA,%sFFFW,%sFNFA,%sFNFW,%sSCDA,%sSCDW,\n"
  81      " %sGCDA,%sGCDW\n"),
  82      privs,
  83          p_OpenProcessToken?"":"!",
  84          p_AdjustTokenPrivileges?"":"!",
  85          p_LookupPrivilegeValue?"":"!",
  86
  87     p_CreateFileA?"":"!",
  88          p_CreateFileW?"":"!",
  89
  90     p_wunlink?"":"!",
  91     p_wmkdir?"":"!",
  92     p_wopen?"":"!",
  93
  94     p_GetFileAttributesA?"":"!",
  95     p_GetFileAttributesW?"":"!",
  96
  97     p_GetFileAttributesExA?"":"!",
  98          p_GetFileAttributesExW?"":"!",
  99
 100     p_SetFileAttributesA?"":"!",
 101          p_SetFileAttributesW?"":"!",
 102          p_BackupRead?"":"!",
 103          p_BackupWrite?"":"!",
 104          p_SetProcessShutdownParameters?"":"!",
 105
 106     p_WideCharToMultiByte?"":"!",
 107     p_MultiByteToWideChar?"":"!",
 108
 109     p_FindFirstFileA?"":"!",
 110     p_FindFirstFileW?"":"!",
 111
 112     p_FindNextFileA?"":"!",
 113     p_FindNextFileW?"":"!",
 114
 115     p_SetCurrentDirectoryA?"":"!",
 116     p_SetCurrentDirectoryW?"":"!",
 117
 118     p_GetCurrentDirectoryA?"":"!",
 119     p_GetCurrentDirectoryW?"":"!");
 120       sendit(msg, len, arg);
 121    }
 122 #endif
 123    if (debug_level > 0) {
 124       len = Mmsg(msg, _(" Heap: bytes=%s max_bytes=%s bufs=%s max_bufs=%s\n"),
 125             edit_uint64_with_commas(sm_bytes, b1),
 126             edit_uint64_with_commas(sm_max_bytes, b2),
 127             edit_uint64_with_commas(sm_buffers, b3),
 128             edit_uint64_with_commas(sm_max_buffers, b4));
 129       sendit(msg, len, arg);
 130       len = Mmsg(msg, _(" Sizeof: off_t=%d size_t=%d debug=%d trace=%d\n"),
 131             sizeof(off_t), sizeof(size_t), debug_level, get_trace());
 132       sendit(msg, len, arg);
 133    }
 134
 135    list_terminated_jobs(sendit, arg);
 136
 137    /*
 138     * List running jobs
 139     */
 140    Dmsg0(1000, "Begin status jcr loop.\n");
 141    len = Mmsg(msg, _("Running Jobs:\n"));
 142    sendit(msg, len, arg);
 143    lock_jcr_chain();
 144    foreach_jcr(njcr) {
 145       bstrftime_nc(dt, sizeof(dt), njcr->start_time);
 146       if (njcr->JobId == 0) {
 147          len = Mmsg(msg, _("Director connected at: %s\n"), dt);
 148       } else {
 149          len = Mmsg(msg, _("JobId %d Job %s is running.\n"),
 150                     njcr->JobId, njcr->Job);
 151          sendit(msg, len, arg);
 152          len = Mmsg(msg, _("    %s Job started: %s\n"),
 153                     job_type_to_str(njcr->JobType), dt);
 154       }
 155       sendit(msg, len, arg);
 156       if (njcr->JobId == 0) {
 157          free_locked_jcr(njcr);
 158          continue;
 159       }
 160       sec = time(NULL) - njcr->start_time;
 161       if (sec <= 0) {
 162          sec = 1;
 163       }
 164       bps = (int)(njcr->JobBytes / sec);
 165       len = Mmsg(msg,  _("    Files=%s Bytes=%s Bytes/sec=%s\n"),
 166            edit_uint64_with_commas(njcr->JobFiles, b1),
 167            edit_uint64_with_commas(njcr->JobBytes, b2),
 168            edit_uint64_with_commas(bps, b3));
 169       sendit(msg, len, arg);
 170       len = Mmsg(msg, _("    Files Examined=%s\n"),
 171            edit_uint64_with_commas(njcr->num_files_examined, b1));
 172       sendit(msg, len, arg);
 173       if (njcr->JobFiles > 0) {
 174          P(njcr->mutex);
 175          len = Mmsg(msg, _("    Processing file: %s\n"), njcr->last_fname);
 176          V(njcr->mutex);
 177          sendit(msg, len, arg);
 178       }
 179
 180       found = 1;
 181       if (njcr->store_bsock) {
 182          len = Mmsg(msg, "    SDReadSeqNo=%" lld " fd=%d\n",
 183              njcr->store_bsock->read_seqno, njcr->store_bsock->fd);
 184          sendit(msg, len, arg);
 185       } else {
 186          len = Mmsg(msg, _("    SDSocket closed.\n"));
 187          sendit(msg, len, arg);
 188       }
 189       free_locked_jcr(njcr);
 190    }
 191    unlock_jcr_chain();
 192    Dmsg0(1000, "Begin status jcr loop.\n");
 193    if (!found) {
 194       len = Mmsg(msg, _("No Jobs running.\n"));
 195       sendit(msg, len, arg);
 196    }
 197    len = Mmsg(msg, _("====\n"));
 198    sendit(msg, len, arg);
 199    free_pool_memory(msg);
 200 }
 201
 202 static void  list_terminated_jobs(void sendit(const char *msg, int len, void *sarg), void *arg)
 203 {
 204    char dt[MAX_TIME_LENGTH], b1[30], b2[30];
 205    char level[10];
 206    struct s_last_job *je;
 207    const char *msg;
 208
 209    if (last_jobs->size() == 0) {
 210       msg = _("No Terminated Jobs.\n");
 211       sendit(msg, strlen(msg), arg);
 212       return;
 213    }
 214    lock_last_jobs_list();
 215    sendit("\n", 1, arg);               /* send separately */
 216    msg =  _("Terminated Jobs:\n");
 217    sendit(msg, strlen(msg), arg);
 218    msg =  _(" JobId  Level     Files         Bytes  Status   Finished        Name \n");
 219    sendit(msg, strlen(msg), arg);
 220    msg = _("======================================================================\n");
 221    sendit(msg, strlen(msg), arg);
 222    foreach_dlist(je, last_jobs) {
 223       char JobName[MAX_NAME_LENGTH];
 224       const char *termstat;
 225       char buf[1000];
 226
 227       bstrftime_nc(dt, sizeof(dt), je->end_time);
 228       switch (je->JobType) {
 229       case JT_ADMIN:
 230       case JT_RESTORE:
 231          bstrncpy(level, "    ", sizeof(level));
 232          break;
 233       default:
 234          bstrncpy(level, level_to_str(je->JobLevel), sizeof(level));
 235          level[4] = 0;
 236          break;
 237       }
 238       switch (je->JobStatus) {
 239       case JS_Created:
 240          termstat = "Created";
 241          break;
 242       case JS_FatalError:
 243       case JS_ErrorTerminated:
 244          termstat = "Error";
 245          break;
 246       case JS_Differences:
 247          termstat = "Diffs";
 248          break;
 249       case JS_Canceled:
 250          termstat = "Cancel";
 251          break;
 252       case JS_Terminated:
 253          termstat = "OK";
 254          break;
 255       default:
 256          termstat = "Other";
 257          break;
 258       }
 259       bstrncpy(JobName, je->Job, sizeof(JobName));
 260       /* There are three periods after the Job name */
 261       char *p;
 262       for (int i=0; i<3; i++) {
 263          if ((p=strrchr(JobName, '.')) != NULL) {
 264             *p = 0;
 265          }
 266       }
 267       bsnprintf(buf, sizeof(buf), _("%6d  %-6s %8s %14s %-7s  %-8s %s\n"),
 268          je->JobId,
 269          level,
 270          edit_uint64_with_commas(je->JobFiles, b1),
 271          edit_uint64_with_commas(je->JobBytes, b2),
 272          termstat,
 273          dt, JobName);
 274       sendit(buf, strlen(buf), arg);
 275    }
 276    sendit("====\n", 5, arg);
 277    unlock_last_jobs_list();
 278 }
 279
 280
 281 /*
 282  * Send to bsock (Director or Console)
 283  */
 284 static void bsock_sendit(const char *msg, int len, void *arg)
 285 {
 286    BSOCK *user = (BSOCK *)arg;
 287
 288    user->msg = check_pool_memory_size(user->msg, len+1);
 289    memcpy(user->msg, msg, len+1);
 290    user->msglen = len+1;
 291    bnet_send(user);
 292 }
 293
 294 /*
 295  * Status command from Director
 296  */
 297 int status_cmd(JCR *jcr)
 298 {
 299    BSOCK *user = jcr->dir_bsock;
 300
 301    bnet_fsend(user, "\n");
 302    do_status(bsock_sendit, (void *)user);
 303
 304    bnet_sig(user, BNET_EOD);
 305    return 1;
 306 }
 307
 308 /*
 309  * .status command from Director
 310  */
 311 int qstatus_cmd(JCR *jcr)
 312 {
 313    BSOCK *dir = jcr->dir_bsock;
 314    POOLMEM *time;
 315    JCR *njcr;
 316    s_last_job* job;
 317
 318    time = get_memory(dir->msglen+1);
 319
 320    if (sscanf(dir->msg, qstatus, time) != 1) {
 321       pm_strcpy(&jcr->errmsg, dir->msg);
 322       Jmsg1(jcr, M_FATAL, 0, _("Bad .status command: %s\n"), jcr->errmsg);
 323       bnet_fsend(dir, "2900 Bad .status command, missing argument.\n");
 324       bnet_sig(dir, BNET_EOD);
 325       free_memory(time);
 326       return 0;
 327    }
 328    unbash_spaces(time);
 329
 330    if (strcmp(time, "current") == 0) {
 331       bnet_fsend(dir, OKqstatus, time);
 332       lock_jcr_chain();
 333       foreach_jcr(njcr) {
 334          if (njcr->JobId != 0) {
 335             bnet_fsend(dir, DotStatusJob, njcr->JobId, njcr->JobStatus, njcr->JobErrors);
 336          }
 337          free_locked_jcr(njcr);
 338       }
 339       unlock_jcr_chain();
 340    }
 341    else if (strcmp(time, "last") == 0) {
 342       bnet_fsend(dir, OKqstatus, time);
 343       if ((last_jobs) && (last_jobs->size() > 0)) {
 344          job = (s_last_job*)last_jobs->last();
 345          bnet_fsend(dir, DotStatusJob, job->JobId, job->JobStatus, job->Errors);
 346       }
 347    }
 348    else {
 349       pm_strcpy(&jcr->errmsg, dir->msg);
 350       Jmsg1(jcr, M_FATAL, 0, _("Bad .status command: %s\n"), jcr->errmsg);
 351       bnet_fsend(dir, "2900 Bad .status command, wrong argument.\n");
 352       bnet_sig(dir, BNET_EOD);
 353       free_memory(time);
 354       return 0;
 355    }
 356
 357    bnet_sig(dir, BNET_EOD);
 358    free_memory(time);
 359    return 1;
 360 }
 361
 362 /*
 363  * Convert Job Level into a string
 364  */
 365 static const char *level_to_str(int level)
 366 {
 367    const char *str;
 368
 369    switch (level) {
 370    case L_BASE:
 371       str = _("Base");
 372    case L_FULL:
 373       str = _("Full");
 374       break;
 375    case L_INCREMENTAL:
 376       str = _("Incremental");
 377       break;
 378    case L_DIFFERENTIAL:
 379       str = _("Differential");
 380       break;
 381    case L_SINCE:
 382       str = _("Since");
 383       break;
 384    case L_VERIFY_CATALOG:
 385       str = _("Verify Catalog");
 386       break;
 387    case L_VERIFY_INIT:
 388       str = _("Init Catalog");
 389       break;
 390    case L_VERIFY_VOLUME_TO_CATALOG:
 391       str = _("Volume to Catalog");
 392       break;
 393    case L_VERIFY_DISK_TO_CATALOG:
 394       str = _("Disk to Catalog");
 395       break;
 396    case L_VERIFY_DATA:
 397       str = _("Data");
 398       break;
 399    case L_NONE:
 400       str = " ";
 401       break;
 402    default:
 403       str = _("Unknown Job Level");
 404       break;
 405    }
 406    return str;
 407 }
 408
 409
 410 #if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
 411 #include <windows.h>
 412
 413 int bacstat = 0;
 414
 415 struct s_win32_arg {
 416    HWND hwnd;
 417    int idlist;
 418 };
 419
 420 /*
 421  * Put message in Window List Box
 422  */
 423 static void win32_sendit(const char *msg, int len, void *marg)
 424 {
 425    struct s_win32_arg *arg = (struct s_win32_arg *)marg;
 426
 427    if (len > 0 && msg[len-1] == '\n') {
 428        // when compiling with visual studio some strings are read-only
 429        // and cause access violations.  So we creat a tmp copy.
 430        char *_msg = (char *)alloca(len);
 431        bstrncpy(_msg, msg, len);
 432        msg = _msg;
 433    }
 434    SendDlgItemMessage(arg->hwnd, arg->idlist, LB_ADDSTRING, 0, (LONG)msg);
 435
 436 }
 437
 438 void FillStatusBox(HWND hwnd, int idlist)
 439 {
 440    struct s_win32_arg arg;
 441
 442    arg.hwnd = hwnd;
 443    arg.idlist = idlist;
 444
 445    /* Empty box */
 446    for ( ; SendDlgItemMessage(hwnd, idlist, LB_DELETESTRING, 0, (LONG)0) > 0; )
 447       { }
 448    do_status(win32_sendit, (void *)&arg);
 449 }
 450
 451 char *bac_status(char *buf, int buf_len)
 452 {
 453    JCR *njcr;
 454    const char *termstat = _("Bacula Idle");
 455    struct s_last_job *job;
 456    int stat = 0;                      /* Idle */
 457
 458    if (!last_jobs) {
 459       goto done;
 460    }
 461    Dmsg0(1000, "Begin bac_status jcr loop.\n");
 462    lock_jcr_chain();
 463    foreach_jcr(njcr) {
 464       if (njcr->JobId != 0) {
 465          stat = JS_Running;
 466          termstat = _("Bacula Running");
 467          free_locked_jcr(njcr);
 468          break;
 469       }
 470       free_locked_jcr(njcr);
 471    }
 472    unlock_jcr_chain();
 473    if (stat != 0) {
 474       goto done;
 475    }
 476    if (last_jobs->size() > 0) {
 477       job = (struct s_last_job *)last_jobs->last();
 478       stat = job->JobStatus;
 479       switch (job->JobStatus) {
 480       case JS_Canceled:
 481          termstat = _("Last Job Canceled");
 482          break;
 483       case JS_ErrorTerminated:
 484       case JS_FatalError:
 485          termstat = _("Last Job Failed");
 486          break;
 487       default:
 488          if (job->Errors) {
 489             termstat = _("Last Job had Warnings");
 490          }
 491          break;
 492       }
 493    }
 494    Dmsg0(1000, "End bac_status jcr loop.\n");
 495 done:
 496    bacstat = stat;
 497    if (buf) {
 498       bstrncpy(buf, termstat, buf_len);
 499    }
 500    return buf;
 501 }
 502
 503 #endif /* HAVE_CYGWIN */