void ndmta_mover_start_active (struct ndm_session *sess) { struct ndm_tape_agent * ta = sess->tape_acb; ndmalogf (sess, 0, 6, "mover going active"); ndma_send_logmsg(sess, NDMP9_LOG_DEBUG, sess->plumb.control, "mover going active"); switch (ta->mover_state.mode) { case NDMP9_MOVER_MODE_READ: ndmis_tape_start (sess, NDMCHAN_MODE_READ); ndmta_mover_active (sess); break; case NDMP9_MOVER_MODE_WRITE: ndmis_tape_start (sess, NDMCHAN_MODE_WRITE); ndmta_mover_active (sess); break; default: ndmalogf (sess, 0, 0, "BOTCH mover listen, unknown mode"); break; } }
/* VERY VERY HARD */ int ndmca_monitor_seek_tape (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; int rc; uint64_t pos; pos = ca->last_notify_mover_paused.seek_position; ndmalogf (sess, 0, 1, "Operation requires a different tape"); /* ndmca_media_capture_mover_window (sess); // !!! */ ndmca_media_calculate_offsets (sess); rc = ndmca_media_unload_current(sess); if (rc) return rc; rc = ndmca_media_load_seek (sess, pos); if (rc) return rc; rc = ndmca_media_set_window_current (sess); if (rc) return rc; rc = ndmca_mover_continue(sess); if (rc) return rc; ndmalogf (sess, 0, 1, "Operation resuming"); return 0; }
int ndmca_media_open_tape (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; int rc; unsigned int t; ndmalogf (sess, 0, 1, "Opening tape drive %s %s", ca->job.tape_device, (ca->tape_mode == NDMP9_TAPE_RDWR_MODE) ? "read/write" : "read-only"); rc = -1; for (t = 0; t <= ca->job.tape_timeout; t += 10) { if (t > 0) { ndmalogf (sess, 0, 1, "Pausing ten seconds before retry (%d/%d)", t, ca->job.tape_timeout); sleep (10); } rc = ndmca_tape_open(sess); if (rc == 0) break; } if (rc) { /* should interpret the error */ ndmalogf (sess, 0, 0, "failed open tape drive %s %s", ca->job.tape_device, (ca->tape_mode == NDMP9_TAPE_RDWR_MODE) ? "read/write" : "read-only"); } return rc; }
int ndmca_media_tattle (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; struct ndm_job_param * job = &ca->job; struct ndmmedia * me; int line, nline; if (!sess->dump_media_info) { return 0; } for (me = job->media_tab.head; me; me = me->next) { char buf[80]; nline = ndmmedia_pp (me, 0, buf); ndmalogf (sess, 0, 1, "media #%d %s", me->index, buf); for (line = 1; line < nline; line++) { nline = ndmmedia_pp (me, line, buf); ndmalogf (sess, 0, 2, " %s", buf); } } return 0; }
int ndmca_monitor_get_post_backup_env (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; struct ndmlog * ixlog = &ca->job.index_log; struct ndm_env_entry * entry; int rc; rc = ndmca_data_get_env (sess); if (rc && ca->data_state.error == NDMP9_ILLEGAL_STATE_ERR) { ndmalogf (sess, 0, 2, "fetch post backup env failed"); return 0; } if (rc) { ndmalogf (sess, 0, 0, "fetch post backup env failed"); return -1; } /* * Only print the data when a deliver function was defined. */ if (ixlog->deliver) { for (entry = ca->job.result_env_tab.head; entry; entry = entry->next) { ndmlogf (ixlog, "DE", 0, "%s=%s", entry->pval.name, entry->pval.value); } } return 0; }
int ndmca_monitor_load_next (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; int rc; ndmalogf (sess, 0, 1, "Operation requires next tape"); ndmca_media_capture_mover_window (sess); ndmca_media_calculate_offsets (sess); if (ca->tape_mode == NDMP9_TAPE_RDWR_MODE) { if (ca->mover_state.pause_reason != NDMP9_MOVER_PAUSE_EOM) ndmca_media_write_filemarks (sess); else ndmalogf (sess, 0, 1, "At EOM, not writing filemarks"); } rc = ndmca_media_unload_current(sess); if (rc) return rc; rc = ndmca_media_load_next(sess); if (rc) return rc; rc = ndmca_media_set_window_current (sess); if (rc) return rc; rc = ndmca_mover_continue(sess); if (rc) return rc; ndmalogf (sess, 0, 1, "Operation resuming"); return 0; }
int ndmca_op_init_labels (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; struct ndm_job_param * job = &ca->job; struct ndm_media_table *mtab = &job->media_tab; int n_media = mtab->n_media; struct ndmmedia * me; int rc, errors; ca->tape_mode = NDMP9_TAPE_RDWR_MODE; ca->is_label_op = 1; if (n_media <= 0) { ndmalogf (sess, 0, 0, "No media entries in table"); return -1; } errors = 0; for (me = mtab->head; me; me = me->next) { if (me->valid_label) continue; ndmalogf (sess, 0, 0, "media #%d missing a label", me->index); errors++; } if (errors) return -1; rc = ndmca_op_robot_startup (sess, 1); if (rc) return rc; /* already tattled */ rc = ndmca_connect_tape_agent (sess); if (rc) { ndmconn_destruct (sess->plumb.tape); sess->plumb.tape = NULL; return rc; /* already tattled */ } for (me = mtab->head; me; me = me->next) { ca->cur_media_ix = me->index; rc = ndmca_media_load_current (sess); if (rc) { /* already tattled */ continue; } rc = ndmca_media_write_label (sess, 'm', me->label); if (rc) { ndmalogf (sess, 0, 0, "failed label write"); } ndmca_media_write_filemarks(sess); ndmca_media_unload_current (sess); } return rc; }
int ndmca_test_data_listen (struct ndm_session *sess, ndmp9_error expect_err, ndmp9_addr_type addr_type) { struct ndmconn * conn = sess->plumb.data; struct ndm_control_agent *ca = sess->control_acb; int rc; /* close previous test if there is one */ ndmca_test_close (sess); switch (conn->protocol_version) { default: return -1234; #ifndef NDMOS_OPTION_NO_NDMP3 case NDMP3VER: NDMC_WITH(ndmp3_data_listen, NDMP3VER) request->addr_type = addr_type; rc = NDMTEST_CALL(conn); if (rc) return rc; if (expect_err == NDMP9_NO_ERR && request->addr_type != reply->data_connection_addr.addr_type) { /* TODO: use proper test format */ ndmalogf (sess, "Test", 1, "DATA_LISTEN addr_type mismatch"); return -1; } ndmp_3to9_addr (&reply->data_connection_addr, &ca->data_addr); NDMC_ENDWITH break; #endif /* !NDMOS_OPTION_NO_NDMP3 */ #ifndef NDMOS_OPTION_NO_NDMP4 case NDMP4VER: NDMC_WITH(ndmp4_data_listen, NDMP4VER) request->addr_type = addr_type; rc = NDMTEST_CALL(conn); if (rc) return rc; if (expect_err == NDMP9_NO_ERR && request->addr_type != reply->connect_addr.addr_type) { /* TODO: use proper test format */ ndmalogf (sess, "Test", 1, "DATA_LISTEN addr_type mismatch"); return -1; } ndmp_4to9_addr (&reply->connect_addr, &ca->data_addr); NDMC_ENDWITH break; #endif /* !NDMOS_OPTION_NO_NDMP4 */ } return 0; }
int ndmca_connect_xxx_agent ( struct ndm_session *sess, struct ndmconn **connp, char *prefix, struct ndmagent *agent) { struct ndmconn * conn = *connp; char * err; int rc; if (conn) return 0; /* already connected */ if (agent->conn_type == NDMCONN_TYPE_NONE) { ndmalogf (sess, 0, 0, "agent %s not give", prefix+1); return -1; } conn = ndmconn_initialize (0, prefix); if (!conn) { ndmalogf (sess, prefix, 0, "can't init connection"); return -1; } if (sess->control_acb.job.time_limit > 0) conn->time_limit = sess->control_acb.job.time_limit; ndmconn_set_snoop (conn, &sess->param.log, sess->param.log_level); conn->call = ndma_call; conn->context = sess; conn->unexpected = ndma_dispatch_ctrl_unexpected; rc = ndmconn_connect_agent (conn, agent); if (rc) { err = "Can't connect"; goto error_out; } rc = ndmconn_auth_agent (conn, agent); if (rc) { err = "Can't auth (bad pw?)"; goto error_out; } *connp = conn; return 0; error_out: ndmalogf (sess, prefix, 0, "err %s", ndmconn_get_err_msg (conn)); //ndmconn_destruct (conn); *connp = conn; return -1; }
int ndmca_op_recover_files (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; int rc; ca->tape_mode = NDMP9_TAPE_READ_MODE; ca->mover_mode = NDMP9_MOVER_MODE_WRITE; ca->is_label_op = 0; rc = ndmca_backreco_startup (sess); if (rc) return rc; rc = ndmca_data_start_recover (sess); if (rc == 0) { rc = ndmca_monitor_startup (sess); if (rc == 0) { rc = ndmca_monitor_recover (sess); } } if (rc == 0) rc = ndmca_monitor_shutdown (sess); else ndmca_monitor_shutdown (sess); if (rc == 0) { if (ca->recover_log_file_count > 0) { struct ndm_control_agent *ca = sess->control_acb; int n_nlist = ca->job.nlist_tab.n_nlist; ndmalogf (sess, 0, 0, "LOG_FILE messages: %d OK, %d ERROR, total %d of %d", ca->recover_log_file_ok, ca->recover_log_file_error, ca->recover_log_file_count, n_nlist); if (ca->recover_log_file_ok < n_nlist) { ndmalogf (sess, 0, 0, "LOG_FILE messages: WARNING OK(%d) < (%d)Expected in namelist", ca->recover_log_file_ok, n_nlist); } if (ca->recover_log_file_ok < ca->recover_log_file_count) { rc = 1; } } else { ndmalogf (sess, 0, 1, "DATA did not report any LOG_FILE messages"); } } if(!ca->job.tape_tcp) ndmca_media_tattle (sess); return rc; }
int ndmta_quantum (struct ndm_session *sess) { struct ndm_tape_agent * ta = &sess->tape_acb; int rc = 0; /* did nothing */ switch (ta->mover_state.state) { default: ndmalogf (sess, 0, 0, "BOTCH mover state"); return -1; case NDMP9_MOVER_STATE_IDLE: case NDMP9_MOVER_STATE_PAUSED: case NDMP9_MOVER_STATE_HALTED: break; case NDMP9_MOVER_STATE_LISTEN: switch (sess->plumb.image_stream.tape_ep.connect_status) { case NDMIS_CONN_LISTEN: /* no connection yet */ break; case NDMIS_CONN_ACCEPTED: /* we're in business */ ndmta_mover_start_active (sess); rc = 1; /* did something */ break; case NDMIS_CONN_BOTCHED: /* accept() went south */ default: /* ain't suppose to happen */ ndmta_mover_halt(sess,NDMP9_MOVER_HALT_CONNECT_ERROR); break; } break; case NDMP9_MOVER_STATE_ACTIVE: switch (ta->mover_state.mode) { case NDMP9_MOVER_MODE_READ: rc = ndmta_read_quantum (sess); break; case NDMP9_MOVER_MODE_WRITE: rc = ndmta_write_quantum (sess); break; default: ndmalogf (sess, 0, 0, "BOTCH mover active, unknown mode"); return -1; } break; } ndmta_mover_send_notice (sess); return rc; }
int ndmca_monitor_backup_tape_tcp (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; int count; ndmp9_data_state ds; char *estb; ndmalogf (sess, 0, 3, "Monitoring backup"); for (count = 0; count < 10; count++) { ndmca_mon_wait_for_something (sess, count <= 1 ? 30 : 10); if (ndmca_monitor_get_states(sess) < 0) break; #if 0 if (count > 2) ndmca_mon_show_states(sess); #endif ds = ca->data_state.state; estb = ndmca_data_est(ca); ndmalogf (sess, 0, 1, "DATA: bytes %lldKB%s", ca->data_state.bytes_processed/1024LL, estb ? estb : ""); ca->job.bytes_written = ca->data_state.bytes_processed; if (ds == NDMP9_DATA_STATE_ACTIVE) { count = 0; continue; } /* * If DATA has halted, the show is over. */ if (ds == NDMP9_DATA_STATE_HALTED) { ndmalogf (sess, 0, 2, "Operation done, cleaning up"); ndmca_monitor_get_post_backup_env (sess); return 0; } } ndmalogf (sess, 0, 0, "Operation monitoring mishandled, cancelling"); return -1; }
int ndmca_monitor_startup (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; ndmp9_data_state ds; ndmp9_mover_state ms; int count; ndmalogf (sess, 0, 3, "Waiting for operation to start"); if (ca->job.tape_tcp) return 0; for (count = 0; count < 10; count++) { if (ndmca_monitor_get_states (sess) < 0) break; ds = ca->data_state.state; if (!ca->job.tape_tcp) ms = ca->mover_state.state; else ms = NDMP9_MOVER_STATE_ACTIVE; if (ds == NDMP9_DATA_STATE_ACTIVE && ms == NDMP9_MOVER_STATE_ACTIVE) { ndmalogf (sess, 0, 1, "Operation started"); return 0; } if (ds == NDMP9_DATA_STATE_HALTED && ms == NDMP9_MOVER_STATE_HALTED) { /* operation finished immediately */ return 0; } if (ds != NDMP9_DATA_STATE_IDLE && ms != NDMP9_MOVER_STATE_IDLE && ms != NDMP9_MOVER_STATE_LISTEN) { ndmalogf (sess, 0, 1, "Operation started in unusual fashion"); return 0; } ndmca_mon_wait_for_something (sess, 2); } ndmalogf (sess, 0, 0, "Operation failed to start"); return -1; }
static ndmp9_error scsi_fail_with_sense_code(struct ndm_session *sess, ndmp9_execute_cdb_reply *reply, int status, int sense_key, int asq) { unsigned char ext_sense[] = { 0x72, /* current errors */ sense_key & SCSI_SENSE_SENSE_KEY_MASK, (asq >> 8) & 0xff, (asq ) & 0xff, 0, 0, 0, 0 }; ndmalogf(sess, 0, 3, "sending failure; status=0x%02x sense_key=0x%02x asq=0x%04x", status, sense_key, asq); reply->status = status; reply->ext_sense.ext_sense_len = sizeof(ext_sense); reply->ext_sense.ext_sense_val = NDMOS_API_MALLOC(sizeof(ext_sense)); NDMOS_API_BCOPY(ext_sense, reply->ext_sense.ext_sense_val, sizeof(ext_sense)); return NDMP9_NO_ERR; }
/* * finish a test phase (part of a series) */ void ndmca_test_done_phase(struct ndm_session* sess) { struct ndm_control_agent* ca = sess->control_acb; char* status; int had_active = (sess->control_acb->active_test != 0); /* close previous test if there is one */ ndmca_test_close(sess); if (ca->n_step_fail) status = "Failed"; else if (ca->n_step_warn) status = "Almost"; else if (ca->n_step_pass > 0) status = "Passed"; else status = "Whiffed"; ndmalogf(sess, "TEST", 0, "Test %s %s -- pass=%d warn=%d fail=%d (total %d)", ca->test_phase, status, ca->n_step_pass, ca->n_step_warn, ca->n_step_fail, ca->n_step_tests); ca->total_n_step_pass += ca->n_step_pass; ca->total_n_step_warn += ca->n_step_warn; ca->total_n_step_fail += ca->n_step_fail; ca->total_n_step_tests += ca->n_step_tests; /* advance test count if we didn't have an active test so * clean up phases have a new test count */ if (!had_active) sess->control_acb->test_step++; }
int ndmca_connect_tape_agent (struct ndm_session *sess) { int rc; if (sess->control_acb.job.tape_agent.conn_type == NDMCONN_TYPE_NONE) { rc = ndmca_connect_data_agent (sess); if (rc) { ndmconn_destruct (sess->plumb.data); return rc; } sess->plumb.tape = sess->plumb.data; rc = 0; } else { rc = ndmca_connect_xxx_agent (sess, &sess->plumb.tape, "#T", &sess->control_acb.job.tape_agent); ndmalogf (sess, 0, 7, "ndmca_connect_tape_agent: %d %p", rc, sess->plumb.tape); } if (rc == 0) { if (sess->plumb.tape->conn_type == NDMCONN_TYPE_RESIDENT) { sess->tape_acb.protocol_version = sess->plumb.tape->protocol_version; } } return rc; }
int ndmca_data_listen (struct ndm_session *sess) { struct ndmconn * conn = sess->plumb.data; struct ndm_control_agent *ca = &sess->control_acb; int rc; NDMC_WITH(ndmp9_data_listen, NDMP9VER) if (sess->plumb.tape == sess->plumb.data) { request->addr_type = NDMP9_ADDR_LOCAL; } else { request->addr_type = NDMP9_ADDR_TCP; } rc = NDMC_CALL(conn); if (rc) return rc; if (request->addr_type != reply->data_connection_addr.addr_type) { ndmalogf (sess, 0, 0, "DATA_LISTEN addr_type mismatch"); return -1; } ca->data_addr = reply->data_connection_addr; NDMC_ENDWITH return 0; }
int ndmca_tt_wrapper (struct ndm_session *sess, int (*func)(struct ndm_session *sess)) { int rc; rc = (*func)(sess); if (rc != 0) { ndmalogf (sess, "Test", 1, "Failure"); } ndmca_test_done_phase (sess); /* clean up mess */ ndmca_test_log_note (sess, 2, "Cleaning up..."); ndmca_tape_open (sess); /* Open the tape, OK if already opened */ ndmca_tape_mtio (sess, NDMP9_MTIO_REW, 1, 0); rc = ndmca_tape_close (sess); /* close, collective error */ if (rc != 0) { ndmca_test_log_note (sess, 0, "Cleaning up failed, quiting"); } else { ndmca_test_log_note (sess, 2, "Cleaning up done"); } return rc; }
int ndmis_tcp_connect (struct ndm_session *sess, struct ndmp9_addr *connect_addr) { struct ndm_image_stream *is = &sess->plumb.image_stream; ndmp9_tcp_addr * tcp_addr=&connect_addr->ndmp9_addr_u.tcp_addr; char * what = "???"; struct sockaddr sa; int connect_sock; NDMOS_MACRO_SET_SOCKADDR (&sa, tcp_addr->ip_addr, tcp_addr->port); what = "socket"; connect_sock = socket (AF_INET, SOCK_STREAM, 0); if (connect_sock < 0) goto fail; what = "connect"; if (connect (connect_sock, &sa, sizeof sa) < 0) goto fail; /* write what we know, ndmis...addrs() will update if possible */ is->remote.peer_addr = *connect_addr; ndmis_tcp_green_light (sess, connect_sock, NDMIS_CONN_CONNECTED); return 0; fail: ndmalogf (sess, 0, 2, "ndmis_tcp_connect(): %s failed", what); if (connect_sock >= 0) close (connect_sock); return -1; }
int ndmca_media_capture_mover_window (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; struct ndmlog * ixlog = &ca->job.index_log; struct ndm_job_param * job = &ca->job; struct ndmmedia * me; ndmp9_mover_state ms = ca->mover_state.state; ndmp9_mover_pause_reason pr = ca->mover_state.pause_reason; char buf[100]; uint64_t wlen; for (me = job->media_tab.head; me; me = me->next) { if (me->index == ca->cur_media_ix) break; } if (!me) { return -1; } if (ms == NDMP9_MOVER_STATE_PAUSED) { if (pr == NDMP9_MOVER_PAUSE_SEEK) { /* end-of-window */ } else if (pr == NDMP9_MOVER_PAUSE_EOM) { me->media_eom = 1; /* tape full */ } else if (pr == NDMP9_MOVER_PAUSE_EOF) { me->media_eof = 1; } else if (pr == NDMP9_MOVER_PAUSE_MEDIA_ERROR) { me->media_io_error = 1; } else { /* what */ } } else if (ms == NDMP9_MOVER_STATE_HALTED) { /* if tape_mode == READ, this may not actually be the window */ /* TODO: should STATE_LISTEN be considered? */ } else { ndmalogf (sess, 0, 1, "Warning: capturing offset w/o quiescent mover"); } wlen = ca->mover_state.record_num; wlen *= job->record_size; wlen -= job->last_w_offset; /* want the size of this image */ me->valid_n_bytes = 1; me->nb_determined = 1; me->n_bytes = wlen; /* * Only print the data when a deliver function was defined. */ if (ixlog->deliver) { ndmmedia_pp (me, 0, buf); ndmlogf (ixlog, "CM", 0, "%02d %s", ca->cur_media_ix, buf); } return 0; }
void ndmca_test_log_note (struct ndm_session *sess, int level, char *msg) { ndmalogf (sess, "Test", level, "%s #%d %s", sess->control_acb.test_phase, sess->control_acb.test_step, msg); }
/* * close or end a test if not already closed */ void ndmca_test_close (struct ndm_session *sess) { if (sess->control_acb.active_test != 0) { /* count test */ sess->control_acb.n_step_tests++; /* display results */ if (sess->control_acb.active_test_failed) { ndmalogf (sess, "Test", 1, "%s #%d -- Failed %s %s", sess->control_acb.test_phase, sess->control_acb.test_step, sess->control_acb.active_test, sess->control_acb.active_test_failed); sess->control_acb.n_step_fail++; exit(1); } else if (sess->control_acb.active_test_warned) { ndmalogf (sess, "Test", 1, "%s #%d -- Almost %s %s", sess->control_acb.test_phase, sess->control_acb.test_step, sess->control_acb.active_test, sess->control_acb.active_test_warned); sess->control_acb.n_step_warn++; exit(1); } else { ndmalogf (sess, "Test", 2, "%s #%d -- Passed %s", sess->control_acb.test_phase, sess->control_acb.test_step, sess->control_acb.active_test); sess->control_acb.n_step_pass++; } /* clear flags */ sess->control_acb.active_test = (char *)0; sess->control_acb.active_test_failed = (char *)0; sess->control_acb.active_test_warned = (char *)0; /* advance test count */ sess->control_acb.test_step++; } }
int ndmca_mon_wait_for_something (struct ndm_session *sess, int max_delay_secs) { struct ndm_control_agent *ca = sess->control_acb; int delta, notices; int time_ref = time(0) + max_delay_secs; ndmalogf (sess, 0, 5, "mon_wait_for_something() entered"); for (;;) { delta = time_ref - time(0); if (delta <= 0) break; notices = 0; if (ca->pending_notify_data_read) { /* leave visible */ notices++; } if (ca->pending_notify_data_halted) { /* just used to "wake up" */ ca->pending_notify_data_halted = 0; notices++; } if (ca->pending_notify_mover_paused) { /* leave visible */ notices++; } if (ca->pending_notify_mover_halted) { /* just used to "wake up" */ ca->pending_notify_mover_halted = 0; notices++; } ndma_session_quantum (sess, notices ? 0 : delta); if (notices) break; } ndmalogf (sess, 0, 5, "mon_wait_for_something() happened, resid=%d", delta); return 0; }
int ndmca_op_test_data (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; struct ndmconn * conn; int (*save_call) (struct ndmconn *conn, struct ndmp_xa_buf *xa); int rc; rc = ndmca_connect_data_agent(sess); if (rc) { ndmconn_destruct (sess->plumb.data); return rc; } conn = sess->plumb.data; save_call = conn->call; conn->call = ndma_call_no_tattle; /* perform query to find out about TCP and LOCAL support */ rc = ndmca_test_query_conn_types (sess, conn); if (rc) return rc; rc = ndmca_td_wrapper (sess, ndmca_td_idle); if (sess->plumb.data->protocol_version >= 3) { // version 3 and later adds LISTEN rc = ndmca_td_wrapper (sess, ndmca_td_listen); } ndmca_test_done_series (sess, "test-data"); ca = sess->control_acb; if (ca->has_tcp_addr && ca->has_local_addr) { ndmalogf (sess, "TEST", 0, "LOCAL and TCP addressing tested."); } else if (ca->has_tcp_addr) { ndmalogf (sess, "TEST", 0, "TCP addressing ONLY tested."); } else if (ca->has_local_addr) { ndmalogf (sess, "TEST", 0, "LOCAL addressing ONLY tested."); } else { ndmalogf (sess, "TEST", 0, "Neither TCP or LOCAL addressing tested."); } return 0; }
/* * start a test phase (part of a series) */ void ndmca_test_phase(struct ndm_session* sess, char* test_phase, char* desc) { ndmalogf(sess, "TEST", 0, "Test %s -- %s", test_phase, desc); sess->control_acb->test_phase = test_phase; sess->control_acb->test_step = 1; sess->control_acb->n_step_pass = 0; sess->control_acb->n_step_fail = 0; sess->control_acb->n_step_warn = 0; sess->control_acb->n_step_tests = 0; }
int ndmca_media_close_tape (struct ndm_session *sess) { struct ndm_control_agent *ca = sess->control_acb; int rc; ndmalogf (sess, 0, 2, "Closing tape drive %s", ca->job.tape_device); rc = ndmca_tape_close (sess); return 0; }
int ndmca_media_mtio_tape (struct ndm_session *sess, ndmp9_tape_mtio_op op, uint32_t count, uint32_t *resid) { int rc; if (op == NDMP9_MTIO_REW) { ndmalogf (sess, 0, 1, "Commanding tape drive to rewind"); } else if (op == NDMP9_MTIO_OFF) { ndmalogf (sess, 0, 1, "Commanding tape drive to eject (go offline)"); } else { ndmalogf (sess, 0, 2, "Commanding tape drive to %s %d times", ndmp9_tape_mtio_op_to_str (op), count); } rc = ndmca_tape_mtio (sess, op, count, resid); return rc; }
/* * TODO: It would be nice that if a media entry has a problem * during load_current() to just skip over it and proceed * to the next one. It will be really annoying to have a * long running backup terminate because of a write-protect * or label-check error when there are perfectly good * tapes available. */ int ndmca_media_load_next (struct ndm_session *sess) { int n_media = sess->control_acb->job.media_tab.n_media; if (sess->control_acb->cur_media_ix >= n_media) { ndmalogf (sess, 0, 0, "Out of tapes"); return -1; } sess->control_acb->cur_media_ix++; return ndmca_media_load_current (sess); }
int ndmis_tcp_get_local_and_peer_addrs (struct ndm_session *sess) { struct ndm_image_stream *is = &sess->plumb.image_stream; char * what = "???"; struct sockaddr sa; struct sockaddr_in * sin = (struct sockaddr_in *) &sa; ndmp9_tcp_addr * tcp_addr; socklen_t len; int rc = 0; len = sizeof sa; what = "getpeername"; if (getpeername (is->chan.fd, &sa, &len) < 0) { /* this is best effort */ ndmalogf (sess, 0, 2, "ndmis_tcp..._addrs(): %s failed", what); rc = -1; } else { is->remote.peer_addr.addr_type = NDMP9_ADDR_TCP; tcp_addr = &is->remote.peer_addr.ndmp9_addr_u.tcp_addr; tcp_addr->ip_addr = ntohl (sin->sin_addr.s_addr); tcp_addr->port = ntohs (sin->sin_port); } len = sizeof sa; what = "getsockname"; if (getsockname (is->chan.fd, &sa, &len) < 0) { /* this is best effort */ ndmalogf (sess, 0, 2, "ndmis_tcp..._addrs(): %s failed", what); rc = -1; } else { is->remote.local_addr.addr_type = NDMP9_ADDR_TCP; tcp_addr = &is->remote.peer_addr.ndmp9_addr_u.tcp_addr; tcp_addr->ip_addr = ntohl (sin->sin_addr.s_addr); tcp_addr->port = ntohs (sin->sin_port); } return rc; }
void ndmca_test_log_step(struct ndm_session* sess, int level, char* msg) { int had_active = (sess->control_acb->active_test != 0); ndmalogf(sess, "Test", level, "%s #%d -- %s", sess->control_acb->test_phase, sess->control_acb->test_step, msg); /* in case we have a open test -- close it */ ndmca_test_close(sess); /* advance test count if we didn't have an active test */ if (!had_active) sess->control_acb->test_step++; }