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

   1 /*
   2  *  This file handles the status command
   3  *
   4  *     Kern Sibbald, May MMIII
   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 "stored.h"
  31
  32 /* Exported variables */
  33
  34 /* Imported variables */
  35 extern BSOCK *filed_chan;
  36 extern int r_first, r_last;
  37 extern struct s_res resources[];
  38 extern char my_name[];
  39 extern time_t daemon_start_time;
  40 extern int num_jobs_run;
  41
  42
  43 /* Static variables */
  44 static char qstatus[] = ".status %s\n";
  45
  46 static char OKqstatus[]   = "3000 OK .status\n";
  47 static char DotStatusJob[] = "JobId=%d JobStatus=%c JobErrors=%d\n";
  48
  49
  50 /* Forward referenced functions */
  51 static void send_blocked_status(JCR *jcr, DEVICE *dev);
  52 static void list_terminated_jobs(void *arg);
  53 static void list_running_jobs(BSOCK *user);
  54 static void sendit(const char *msg, int len, void *arg);
  55 static const char *level_to_str(int level);
  56
  57
  58 /*
  59  * Status command from Director
  60  */
  61 int status_cmd(JCR *jcr)
  62 {
  63    DEVRES *device;
  64    DEVICE *dev;
  65    BSOCK *user = jcr->dir_bsock;
  66    char dt[MAX_TIME_LENGTH];
  67    char b1[30], b2[30], b3[30];
  68    int bpb;
  69
  70    bnet_fsend(user, "\n%s Version: " VERSION " (" BDATE ") %s %s %s\n", my_name,
  71               HOST_OS, DISTNAME, DISTVER);
  72    bstrftime_nc(dt, sizeof(dt), daemon_start_time);
  73    bnet_fsend(user, _("Daemon started %s, %d Job%s run since started.\n"), dt, num_jobs_run,
  74         num_jobs_run == 1 ? "" : "s");
  75    if (debug_level > 0) {
  76       char b1[35], b2[35], b3[35], b4[35];
  77       bnet_fsend(user, _(" Heap: bytes=%s max_bytes=%s bufs=%s max_bufs=%s\n"),
  78             edit_uint64_with_commas(sm_bytes, b1),
  79             edit_uint64_with_commas(sm_max_bytes, b2),
  80             edit_uint64_with_commas(sm_buffers, b3),
  81             edit_uint64_with_commas(sm_max_buffers, b4));
  82    }
  83
  84    /*
  85     * List running jobs
  86     */
  87    list_running_jobs(user);
  88
  89    /*
  90     * List terminated jobs
  91     */
  92    list_terminated_jobs(user);
  93
  94    /*
  95     * List devices
  96     */
  97    bnet_fsend(user, _("\nDevice status:\n"));
  98    LockRes();
  99    foreach_res(device, R_DEVICE) {
 100       for (dev=device->dev; dev; dev=dev->next) {
 101          if (dev_state(dev, ST_OPENED)) {
 102             if (dev_state(dev, ST_LABEL)) {
 103                bnet_fsend(user, _("Device \"%s\" is mounted with Volume \"%s\"\n"),
 104                   dev_name(dev), dev->VolHdr.VolName);
 105             } else {
 106                bnet_fsend(user, _("Device \"%s\" open but no Bacula volume is mounted.\n"), dev_name(dev));
 107             }
 108             send_blocked_status(jcr, dev);
 109             if (dev_state(dev, ST_APPEND)) {
 110                bpb = dev->VolCatInfo.VolCatBlocks;
 111                if (bpb <= 0) {
 112                   bpb = 1;
 113                }
 114                bpb = dev->VolCatInfo.VolCatBytes / bpb;
 115                bnet_fsend(user, _("    Total Bytes=%s Blocks=%s Bytes/block=%s\n"),
 116                   edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
 117                   edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
 118                   edit_uint64_with_commas(bpb, b3));
 119             } else {  /* reading */
 120                bpb = dev->VolCatInfo.VolCatReads;
 121                if (bpb <= 0) {
 122                   bpb = 1;
 123                }
 124                if (dev->VolCatInfo.VolCatRBytes > 0) {
 125                   bpb = dev->VolCatInfo.VolCatRBytes / bpb;
 126                } else {
 127                   bpb = 0;
 128                }
 129                bnet_fsend(user, _("    Total Bytes Read=%s Blocks Read=%s Bytes/block=%s\n"),
 130                   edit_uint64_with_commas(dev->VolCatInfo.VolCatRBytes, b1),
 131                   edit_uint64_with_commas(dev->VolCatInfo.VolCatReads, b2),
 132                   edit_uint64_with_commas(bpb, b3));
 133             }
 134             bnet_fsend(user, _("    Positioned at File=%s Block=%s\n"),
 135                edit_uint64_with_commas(dev->file, b1),
 136                edit_uint64_with_commas(dev->block_num, b2));
 137
 138          } else {
 139             bnet_fsend(user, _("Device \"%s\" is not open.\n"), dev_name(dev));
 140             send_blocked_status(jcr, dev);
 141          }
 142       }
 143    }
 144    UnlockRes();
 145
 146
 147 #ifdef xfull_status
 148    bnet_fsend(user, "\n\n");
 149    dump_resource(R_DEVICE, resources[R_DEVICE-r_first].res_head, sendit, user);
 150 #endif
 151    bnet_fsend(user, "====\n\n");
 152
 153    list_spool_stats(user);
 154
 155    bnet_sig(user, BNET_EOD);
 156    return 1;
 157 }
 158
 159 static void send_blocked_status(JCR *jcr, DEVICE *dev)
 160 {
 161    BSOCK *user = jcr->dir_bsock;
 162
 163    switch (dev->dev_blocked) {
 164    case BST_UNMOUNTED:
 165       bnet_fsend(user, _("    Device is BLOCKED. User unmounted.\n"));
 166       break;
 167    case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 168       bnet_fsend(user, _("    Device is BLOCKED. User unmounted during wait for media/mount.\n"));
 169       break;
 170    case BST_WAITING_FOR_SYSOP:
 171       if (jcr->JobStatus == JS_WaitMount) {
 172          bnet_fsend(user, _("    Device is BLOCKED waiting for mount of volume \"%s\".\n"),
 173             jcr->VolumeName);
 174       } else {
 175          bnet_fsend(user, _("    Device is BLOCKED waiting for appendable media.\n"));
 176       }
 177       break;
 178    case BST_DOING_ACQUIRE:
 179       bnet_fsend(user, _("    Device is being initialized.\n"));
 180       break;
 181    case BST_WRITING_LABEL:
 182       bnet_fsend(user, _("    Device is blocked labeling a Volume.\n"));
 183       break;
 184    default:
 185       break;
 186    }
 187    if (debug_level > 1) {
 188       bnet_fsend(user, _("Configured device capabilities:\n"));
 189       bnet_fsend(user, "%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
 190       bnet_fsend(user, "%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
 191       bnet_fsend(user, "%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
 192       bnet_fsend(user, "%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
 193       bnet_fsend(user, "%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
 194       bnet_fsend(user, "%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
 195       bnet_fsend(user, "%sREM ", dev->capabilities & CAP_REM ? "" : "!");
 196       bnet_fsend(user, "%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
 197       bnet_fsend(user, "%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
 198       bnet_fsend(user, "%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
 199       bnet_fsend(user, "%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
 200       bnet_fsend(user, "%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
 201       bnet_fsend(user, "\n");
 202
 203       bnet_fsend(user, _("Device status:\n"));
 204       bnet_fsend(user, "%sOPENED ", dev->state & ST_OPENED ? "" : "!");
 205       bnet_fsend(user, "%sTAPE ", dev->state & ST_TAPE ? "" : "!");
 206       bnet_fsend(user, "%sLABEL ", dev->state & ST_LABEL ? "" : "!");
 207       bnet_fsend(user, "%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
 208       bnet_fsend(user, "%sAPPEND ", dev->state & ST_APPEND ? "" : "!");
 209       bnet_fsend(user, "%sREAD ", dev->state & ST_READ ? "" : "!");
 210       bnet_fsend(user, "%sEOT ", dev->state & ST_EOT ? "" : "!");
 211       bnet_fsend(user, "%sWEOT ", dev->state & ST_WEOT ? "" : "!");
 212       bnet_fsend(user, "%sEOF ", dev->state & ST_EOF ? "" : "!");
 213       bnet_fsend(user, "%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
 214       bnet_fsend(user, "%sSHORT ", dev->state & ST_SHORT ? "" : "!");
 215       bnet_fsend(user, "\n");
 216
 217       bnet_fsend(user, _("Device parameters:\n"));
 218       bnet_fsend(user, "Device name: %s\n", dev->dev_name);
 219       bnet_fsend(user, "File=%u block=%u\n", dev->file, dev->block_num);
 220       bnet_fsend(user, "Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
 221    }
 222
 223 }
 224
 225 static void list_running_jobs(BSOCK *user)
 226 {
 227    bool found = false;
 228    int bps, sec;
 229    JCR *jcr;
 230    char JobName[MAX_NAME_LENGTH];
 231    char b1[30], b2[30], b3[30];
 232
 233    bnet_fsend(user, _("\nRunning Jobs:\n"));
 234    lock_jcr_chain();
 235    foreach_jcr(jcr) {
 236       if (jcr->JobStatus == JS_WaitFD) {
 237          bnet_fsend(user, _("%s Job %s waiting for Client connection.\n"),
 238             job_type_to_str(jcr->JobType), jcr->Job);
 239       }
 240       if (jcr->device) {
 241          bstrncpy(JobName, jcr->Job, sizeof(JobName));
 242          /* There are three periods after the Job name */
 243          char *p;
 244          for (int i=0; i<3; i++) {
 245             if ((p=strrchr(JobName, '.')) != NULL) {
 246                *p = 0;
 247             }
 248          }
 249          bnet_fsend(user, _("%s %s job %s JobId=%d Volume=\"%s\" device=\"%s\"\n"),
 250                    job_level_to_str(jcr->JobLevel),
 251                    job_type_to_str(jcr->JobType),
 252                    JobName,
 253                    jcr->JobId,
 254                    jcr->VolumeName,
 255                    jcr->device->device_name);
 256          sec = time(NULL) - jcr->run_time;
 257          if (sec <= 0) {
 258             sec = 1;
 259          }
 260          bps = jcr->JobBytes / sec;
 261          bnet_fsend(user, _("    Files=%s Bytes=%s Bytes/sec=%s\n"),
 262             edit_uint64_with_commas(jcr->JobFiles, b1),
 263             edit_uint64_with_commas(jcr->JobBytes, b2),
 264             edit_uint64_with_commas(bps, b3));
 265          found = true;
 266 #ifdef DEBUG
 267          if (jcr->file_bsock) {
 268             bnet_fsend(user, "    FDReadSeqNo=%s in_msg=%u out_msg=%d fd=%d\n",
 269                edit_uint64_with_commas(jcr->file_bsock->read_seqno, b1),
 270                jcr->file_bsock->in_msg_no, jcr->file_bsock->out_msg_no,
 271                jcr->file_bsock->fd);
 272          } else {
 273             bnet_fsend(user, "    FDSocket closed\n");
 274          }
 275 #endif
 276       }
 277       free_locked_jcr(jcr);
 278    }
 279    unlock_jcr_chain();
 280    if (!found) {
 281       bnet_fsend(user, _("No Jobs running.\n"));
 282    }
 283    bnet_fsend(user, "====\n");
 284 }
 285
 286 static void list_terminated_jobs(void *arg)
 287 {
 288    char dt[MAX_TIME_LENGTH], b1[30], b2[30];
 289    char level[10];
 290    struct s_last_job *je;
 291    const char *msg;
 292
 293    if (last_jobs->size() == 0) {
 294       msg = _("No Terminated Jobs.\n");
 295       sendit(msg, strlen(msg), arg);
 296       return;
 297    }
 298    lock_last_jobs_list();
 299    msg =  _("\nTerminated Jobs:\n");
 300    sendit(msg, strlen(msg), arg);
 301    msg =  _(" JobId  Level   Files          Bytes Status   Finished        Name \n");
 302    sendit(msg, strlen(msg), arg);
 303    msg = _("======================================================================\n");
 304    sendit(msg, strlen(msg), arg);
 305    foreach_dlist(je, last_jobs) {
 306       char JobName[MAX_NAME_LENGTH];
 307       const char *termstat;
 308       char buf[1000];
 309
 310       bstrftime_nc(dt, sizeof(dt), je->end_time);
 311       switch (je->JobType) {
 312       case JT_ADMIN:
 313       case JT_RESTORE:
 314          bstrncpy(level, "    ", sizeof(level));
 315          break;
 316       default:
 317          bstrncpy(level, level_to_str(je->JobLevel), sizeof(level));
 318          level[4] = 0;
 319          break;
 320       }
 321       switch (je->JobStatus) {
 322       case JS_Created:
 323          termstat = "Created";
 324          break;
 325       case JS_FatalError:
 326       case JS_ErrorTerminated:
 327          termstat = "Error";
 328          break;
 329       case JS_Differences:
 330          termstat = "Diffs";
 331          break;
 332       case JS_Canceled:
 333          termstat = "Cancel";
 334          break;
 335       case JS_Terminated:
 336          termstat = "OK";
 337          break;
 338       default:
 339          termstat = "Other";
 340          break;
 341       }
 342       bstrncpy(JobName, je->Job, sizeof(JobName));
 343       /* There are three periods after the Job name */
 344       char *p;
 345       for (int i=0; i<3; i++) {
 346          if ((p=strrchr(JobName, '.')) != NULL) {
 347             *p = 0;
 348          }
 349       }
 350       bsnprintf(buf, sizeof(buf), _("%6d  %-6s %8s %14s %-7s  %-8s %s\n"),
 351          je->JobId,
 352          level,
 353          edit_uint64_with_commas(je->JobFiles, b1),
 354          edit_uint64_with_commas(je->JobBytes, b2),
 355          termstat,
 356          dt, JobName);
 357       sendit(buf, strlen(buf), arg);
 358    }
 359    sendit("====\n", 5, arg);
 360    unlock_last_jobs_list();
 361 }
 362
 363 /*
 364  * Convert Job Level into a string
 365  */
 366 static const char *level_to_str(int level)
 367 {
 368    const char *str;
 369
 370    switch (level) {
 371    case L_BASE:
 372       str = _("Base");
 373    case L_FULL:
 374       str = _("Full");
 375       break;
 376    case L_INCREMENTAL:
 377       str = _("Incremental");
 378       break;
 379    case L_DIFFERENTIAL:
 380       str = _("Differential");
 381       break;
 382    case L_SINCE:
 383       str = _("Since");
 384       break;
 385    case L_VERIFY_CATALOG:
 386       str = _("Verify Catalog");
 387       break;
 388    case L_VERIFY_INIT:
 389       str = _("Init Catalog");
 390       break;
 391    case L_VERIFY_VOLUME_TO_CATALOG:
 392       str = _("Volume to Catalog");
 393       break;
 394    case L_VERIFY_DISK_TO_CATALOG:
 395       str = _("Disk to Catalog");
 396       break;
 397    case L_VERIFY_DATA:
 398       str = _("Data");
 399       break;
 400    case L_NONE:
 401       str = " ";
 402       break;
 403    default:
 404       str = _("Unknown Job Level");
 405       break;
 406    }
 407    return str;
 408 }
 409
 410 /*
 411  * Send to Director
 412  */
 413 static void sendit(const char *msg, int len, void *arg)
 414 {
 415    BSOCK *user = (BSOCK *)arg;
 416
 417    memcpy(user->msg, msg, len+1);
 418    user->msglen = len+1;
 419    bnet_send(user);
 420 }
 421
 422 /*
 423  * .status command from Director
 424  */
 425 int qstatus_cmd(JCR *jcr)
 426 {
 427    BSOCK *dir = jcr->dir_bsock;
 428    POOLMEM *time;
 429    JCR *njcr;
 430    s_last_job* job;
 431
 432    time = get_memory(dir->msglen+1);
 433
 434    if (sscanf(dir->msg, qstatus, time) != 1) {
 435       pm_strcpy(&jcr->errmsg, dir->msg);
 436       Jmsg1(jcr, M_FATAL, 0, _("Bad .status command: %s\n"), jcr->errmsg);
 437       bnet_fsend(dir, "3900 Bad .status command, missing argument.\n");
 438       bnet_sig(dir, BNET_EOD);
 439       free_memory(time);
 440       return 0;
 441    }
 442    unbash_spaces(time);
 443
 444    if (strcmp(time, "current") == 0) {
 445       bnet_fsend(dir, OKqstatus, time);
 446       lock_jcr_chain();
 447       foreach_jcr(njcr) {
 448          if (njcr->JobId != 0) {
 449             bnet_fsend(dir, DotStatusJob, njcr->JobId, njcr->JobStatus, njcr->JobErrors);
 450          }
 451          free_locked_jcr(njcr);
 452       }
 453       unlock_jcr_chain();
 454    }
 455    else if (strcmp(time, "last") == 0) {
 456       bnet_fsend(dir, OKqstatus, time);
 457       if ((last_jobs) && (last_jobs->size() > 0)) {
 458          job = (s_last_job*)last_jobs->last();
 459          bnet_fsend(dir, DotStatusJob, job->JobId, job->JobStatus, job->Errors);
 460       }
 461    }
 462    else {
 463       pm_strcpy(&jcr->errmsg, dir->msg);
 464       Jmsg1(jcr, M_FATAL, 0, _("Bad .status command: %s\n"), jcr->errmsg);
 465       bnet_fsend(dir, "3900 Bad .status command, wrong argument.\n");
 466       bnet_sig(dir, BNET_EOD);
 467       free_memory(time);
 468       return 0;
 469    }
 470
 471    bnet_sig(dir, BNET_EOD);
 472    free_memory(time);
 473    return 1;
 474 }