]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/status.c
b9dbce14b688ca2a92ca79aad26144a068e93f09
[bacula/bacula] / 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-2003 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    for (device=NULL;  (device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device)); ) {
80       for (dev=device->dev; dev; dev=dev->next) {
81          if (dev->state & ST_OPENED) {
82             if (dev->state & 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 & 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 }