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