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