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