/*
* ndmpd_abort_making_v2
*
* Abort the process of marking inodes.
*
* Parameters:
* session (input) - pointer to the session
*
* Returns:
* void
*/
void
ndmpd_abort_marking_v2(ndmpd_session_t *session)
{
ndmp_lbr_params_t *nlp;
nlp = ndmp_get_nlp(session);
if (nlp)
NLP_SET(nlp, NLPF_ABORTED);
}
/*
* ndmpd_fhnode_v3_cb
*
* Callback function for file history node information
*/
int
ndmpd_fhnode_v3_cb(lbr_fhlog_call_backs_t *cbp, char *dir, char *file,
struct stat64 *stp, u_longlong_t off)
{
int err;
ulong_t ino;
ndmp_lbr_params_t *nlp;
ndmpd_module_params_t *params;
if (!cbp) {
err = -1;
syslog(LOG_DEBUG, "cbp is NULL");
} else if (!cbp->fh_cookie) {
err = -1;
syslog(LOG_DEBUG, "cookie is NULL");
} else if (!dir) {
err = -1;
syslog(LOG_DEBUG, "dir is NULL");
} else if (!file) {
err = -1;
syslog(LOG_DEBUG, "file is NULL");
} else if (!stp) {
err = -1;
syslog(LOG_DEBUG, "stp is NULL");
} else if (!(nlp = ndmp_get_nlp(cbp->fh_cookie))) {
err = -1;
syslog(LOG_DEBUG, "nlp is NULL");
} else {
err = 0;
}
if (err != 0)
return (0);
err = 0;
if (NLP_ISSET(nlp, NLPF_FH)) {
if (!NLP_ISSET(nlp, NLPF_DIRECT))
off = 0LL;
if (stp->st_ino == nlp->nlp_bkdirino) {
ino = ROOT_INODE;
syslog(LOG_DEBUG,
"bkroot %d -> %d", stp->st_ino, ROOT_INODE);
} else
ino = stp->st_ino;
params = nlp->nlp_params;
if (!params || !params->mp_file_history_node_func)
err = -1;
else if ((err = (*params->mp_file_history_node_func)(cbp->
fh_cookie, ino, stp, off)) < 0)
syslog(LOG_ERR, "\"%s/%s\" %d", dir, file, err);
}
return (err);
}
/*
* get_params
*
* Callbacks from LBR.
*/
static ndmpd_module_params_t *
get_params(void *cookie)
{
ndmp_lbr_params_t *nlp;
if ((nlp = ndmp_get_nlp(cookie)) == NULL)
return (NULL);
return (nlp->nlp_params);
}
/*
* backup_create_structs
*
* Allocate the structures before performing backup
*
* Parameters:
* sesison (input) - session handle
* jname (input) - backup job name
*
* Returns:
* 0: on success
* -1: otherwise
*/
static int
backup_create_structs(ndmpd_session_t *session, char *jname)
{
int n;
long xfer_size;
ndmp_lbr_params_t *nlp;
tlm_commands_t *cmds;
if ((nlp = ndmp_get_nlp(session)) == NULL) {
NDMP_LOG(LOG_DEBUG, "nlp == NULL");
return (-1);
}
if ((nlp->nlp_jstat = tlm_new_job_stats(jname)) == NULL) {
NDMP_LOG(LOG_DEBUG, "Creating job stats");
return (-1);
}
cmds = &nlp->nlp_cmds;
(void) memset(cmds, 0, sizeof (*cmds));
xfer_size = ndmp_buffer_get_size(session);
if (xfer_size < 512*KILOBYTE) {
/*
* Read multiple of mover_record_size near to 512K. This
* will prevent the data being copied in the mover buffer
* when we write the data.
*/
if ((n = (512 * KILOBYTE/xfer_size)) <= 0)
n = 1;
xfer_size *= n;
NDMP_LOG(LOG_DEBUG, "Adjusted read size: %d", xfer_size);
}
cmds->tcs_command = tlm_create_reader_writer_ipc(TRUE, xfer_size);
if (cmds->tcs_command == NULL) {
NDMP_LOG(LOG_DEBUG, "Error creating ipc buffers");
tlm_un_ref_job_stats(jname);
return (-1);
}
nlp->nlp_logcallbacks = lbrlog_callbacks_init(session,
ndmpd_file_history_path,
ndmpd_file_history_dir,
ndmpd_file_history_node);
if (nlp->nlp_logcallbacks == NULL) {
tlm_release_reader_writer_ipc(cmds->tcs_command);
tlm_un_ref_job_stats(jname);
return (-1);
}
nlp->nlp_jstat->js_callbacks = (void *)(nlp->nlp_logcallbacks);
return (0);
}
/*ARGSUSED*/
int
ndmpd_file_history_node(lbr_fhlog_call_backs_t *cbp, char *dir, char *file,
struct stat64 *stp, u_longlong_t off)
{
int err;
ulong_t ino;
ndmp_lbr_params_t *nlp;
ndmpd_module_params_t *params;
if (!cbp) {
err = -1;
syslog(LOG_DEBUG, "cbp is NULL");
} else if (!cbp->fh_cookie) {
err = -1;
syslog(LOG_DEBUG, "cookie is NULL");
} else if (!dir) {
err = -1;
syslog(LOG_DEBUG, "dir is NULL");
} else if (!file) {
err = -1;
syslog(LOG_DEBUG, "file is NULL");
} else if (!stp) {
err = -1;
syslog(LOG_DEBUG, "stp is NULL");
} else if (!(nlp = ndmp_get_nlp(cbp->fh_cookie))) {
err = -1;
syslog(LOG_DEBUG, "nlp is NULL");
} else
err = 0;
if (err != 0)
return (0);
err = 0;
if (fh_requested(cbp->fh_cookie) == TRUE) {
if (stp->st_ino == nlp->nlp_bkdirino) {
ino = ROOT_INODE;
syslog(LOG_DEBUG,
"bkroot %d -> %d", stp->st_ino, ROOT_INODE);
} else {
ino = stp->st_ino;
}
params = get_params(cbp->fh_cookie);
if (params == NULL || params->mp_file_history_node_func == NULL)
err = -1;
else if ((err = (*params->mp_file_history_node_func)(cbp->
fh_cookie, ino, stp, 0)) < 0)
syslog(LOG_DEBUG, "\"%s/\": %d", dir, file, err);
}
return (err);
}
/*
* fh_requested
*
* Check in LB parameters if file history is requested
*/
static boolean_t
fh_requested(void *cookie)
{
ndmp_lbr_params_t *nlp;
if ((nlp = ndmp_get_nlp(cookie)) == NULL) {
syslog(LOG_DEBUG, "nlp is NULL");
return (FALSE);
}
syslog(LOG_DEBUG, "nlp_fh %c", NDMP_YORN(NLP_ISSET(nlp, NLPF_FH)));
return (NLP_ISSET(nlp, NLPF_FH));
}
/*
* restore_create_structs
*
* Allocate structures for performing a restore
*
* Parameters:
* sesison (input) - session handle
* jname (input) - backup job name
*
* Returns:
* 0: on success
* -1: otherwise
*/
static int
restore_create_structs(ndmpd_session_t *session, char *jname)
{
int i;
long xfer_size;
ndmp_lbr_params_t *nlp;
tlm_commands_t *cmds;
if ((nlp = ndmp_get_nlp(session)) == NULL) {
NDMP_LOG(LOG_DEBUG, "nlp == NULL");
return (-1);
}
if ((nlp->nlp_jstat = tlm_new_job_stats(jname)) == NULL) {
NDMP_LOG(LOG_DEBUG, "Creating job stats");
return (-1);
}
cmds = &nlp->nlp_cmds;
(void) memset(cmds, 0, sizeof (*cmds));
xfer_size = ndmp_buffer_get_size(session);
cmds->tcs_command = tlm_create_reader_writer_ipc(FALSE, xfer_size);
if (cmds->tcs_command == NULL) {
NDMP_LOG(LOG_DEBUG, "Error creating ipc buffers");
tlm_un_ref_job_stats(jname);
return (-1);
}
nlp->nlp_logcallbacks = lbrlog_callbacks_init(session,
ndmpd_path_restored, NULL, NULL);
if (nlp->nlp_logcallbacks == NULL) {
tlm_release_reader_writer_ipc(cmds->tcs_command);
tlm_un_ref_job_stats(jname);
return (-1);
}
nlp->nlp_jstat->js_callbacks = (void *)(nlp->nlp_logcallbacks);
nlp->nlp_restored = ndmp_malloc(sizeof (boolean_t) * nlp->nlp_nfiles);
if (nlp->nlp_restored == NULL) {
lbrlog_callbacks_done(nlp->nlp_logcallbacks);
tlm_release_reader_writer_ipc(cmds->tcs_command);
tlm_un_ref_job_stats(jname);
return (-1);
}
for (i = 0; i < (int)nlp->nlp_nfiles; i++)
nlp->nlp_restored[i] = FALSE;
return (0);
}
/*
* ndmpd_fhpath_v3_cb
*
* Callback function for file history path information
*/
int
ndmpd_fhpath_v3_cb(lbr_fhlog_call_backs_t *cbp, char *path, struct stat64 *stp,
u_longlong_t off)
{
int err;
ndmp_lbr_params_t *nlp;
ndmpd_module_params_t *params;
if (!cbp) {
err = -1;
syslog(LOG_DEBUG, "cbp is NULL");
} else if (!cbp->fh_cookie) {
err = -1;
syslog(LOG_DEBUG, "cookie is NULL");
} else if (!path) {
err = -1;
syslog(LOG_DEBUG, "path is NULL");
} else if (!(nlp = ndmp_get_nlp(cbp->fh_cookie))) {
err = -1;
syslog(LOG_DEBUG, "nlp is NULL");
} else
err = 0;
if (err != 0)
return (0);
err = 0;
if (NLP_ISSET(nlp, NLPF_FH)) {
if (!NLP_ISSET(nlp, NLPF_DIRECT)) {
syslog(LOG_DEBUG, "DAR NOT SET!");
off = 0LL;
}
params = get_params(cbp->fh_cookie);
if (!params || !params->mp_file_history_path_func) {
err = -1;
} else {
char *p =
ndmp_get_relative_path(get_backup_path_v3(params),
path);
if ((err = ndmpd_api_file_history_file_v3(cbp->
fh_cookie, p, stp, off)) < 0)
syslog(LOG_DEBUG, "\"%s\" %d", path, err);
}
}
return (err);
}
/*ARGSUSED*/
int
ndmpd_path_restored_v3(lbr_fhlog_call_backs_t *cbp, char *name,
struct stat64 *st, u_longlong_t ll_idx)
{
int rv;
ndmp_lbr_params_t *nlp;
ndmpd_module_params_t *params;
int idx = (int)ll_idx;
if (!cbp) {
syslog(LOG_DEBUG, "cbp is NULL");
return (-1);
}
if (!name) {
syslog(LOG_DEBUG, "name is NULL");
return (-1);
}
nlp = ndmp_get_nlp(cbp->fh_cookie);
if (!nlp) {
syslog(LOG_DEBUG, "nlp is NULL");
return (-1);
}
if (idx < 0 || idx >= nlp->nlp_nfiles) {
syslog(LOG_DEBUG, "Invalid idx: %d", idx);
return (-1);
}
params = nlp->nlp_params;
if (!params || !params->mp_file_recovered_func)
return (-1);
if (nlp->nlp_lastidx == -1)
nlp->nlp_lastidx = idx;
rv = 0;
(void) bm_setone(nlp->nlp_rsbm, (u_longlong_t)idx);
/*
* Note: We should set the nm3_err here.
*/
if (nlp->nlp_lastidx != idx) {
rv = ndmp_send_recovery_stat_v3(params, nlp, nlp->nlp_lastidx,
0);
nlp->nlp_lastidx = idx;
}
return (rv);
}
/*ARGSUSED*/
static void
backup_release_structs(ndmpd_session_t *session)
{
ndmp_lbr_params_t *nlp;
tlm_commands_t *cmds;
if ((nlp = ndmp_get_nlp(session)) == NULL) {
NDMP_LOG(LOG_DEBUG, "nlp == NULL");
return;
}
cmds = &nlp->nlp_cmds;
if (cmds == NULL) {
NDMP_LOG(LOG_DEBUG, "cmds == NULL");
return;
}
if (nlp->nlp_logcallbacks != NULL) {
lbrlog_callbacks_done(nlp->nlp_logcallbacks);
nlp->nlp_logcallbacks = NULL;
} else {
NDMP_LOG(LOG_DEBUG, "FH CALLBACKS == NULL");
}
if (cmds->tcs_command != NULL) {
if (cmds->tcs_command->tc_buffers != NULL)
tlm_release_reader_writer_ipc(cmds->tcs_command);
else
NDMP_LOG(LOG_DEBUG, "BUFFERS == NULL");
cmds->tcs_command = NULL;
} else {
NDMP_LOG(LOG_DEBUG, "COMMAND == NULL");
}
if (nlp->nlp_bkmap >= 0) {
(void) dbm_free(nlp->nlp_bkmap);
nlp->nlp_bkmap = -1;
}
if (session->ns_data.dd_operation == NDMP_DATA_OP_RECOVER &&
nlp->nlp_restored != NULL) {
free(nlp->nlp_restored);
nlp->nlp_restored = NULL;
} else {
NDMP_LOG(LOG_DEBUG, "nlp_restored == NULL");
}
}
/*ARGSUSED*/
int
ndmpd_path_restored(lbr_fhlog_call_backs_t *cbp, char *name, struct stat64 *stp,
u_longlong_t ll_pos)
{
int rv;
ndmp_name *entp;
ndmp_lbr_params_t *nlp;
ndmpd_module_params_t *params;
int pos = (int)ll_pos;
if (cbp == NULL) {
syslog(LOG_DEBUG, "cbp is NULL");
return (-1);
}
if (name == NULL) {
syslog(LOG_DEBUG, "name is NULL");
return (-1);
}
if ((nlp = ndmp_get_nlp(cbp->fh_cookie)) == NULL) {
syslog(LOG_DEBUG, "nlp is NULL");
return (-1);
}
if (pos < 0 || pos >= nlp->nlp_nfiles) {
syslog(LOG_DEBUG, "Invalid pos: %d", pos);
return (-1);
}
params = get_params(cbp->fh_cookie);
if (params == NULL || params->mp_file_recovered_func == NULL)
return (-1);
rv = 0;
if (!nlp->nlp_restored[pos]) {
entp = (ndmp_name *)MOD_GETNAME(params, pos);
if (entp && entp->name)
name = entp->name;
if ((rv = MOD_FILERECOVERD(params, name, 0)) >= 0)
nlp->nlp_restored[pos] = TRUE;
}
return (rv);
}
int
ndmpd_tar_restore_starter(void *arg)
{
ndmpd_module_params_t *mod_params = arg;
int err;
ndmpd_session_t *session;
ndmp_lbr_params_t *nlp;
session = (ndmpd_session_t *)(mod_params->mp_daemon_cookie);
*(mod_params->mp_module_cookie) = nlp = ndmp_get_nlp(session);
ndmp_session_ref(session);
err = ndmpd_tar_restore(session, mod_params, nlp);
MOD_DONE(mod_params, err);
/* nlp_params is allocated in start_recover() */
NDMP_FREE(nlp->nlp_params);
NS_DEC(nrs);
ndmp_session_unref(session);
return (err);
}
/*
* mark_cb
*
* The callback function, called by traverse_post to mark bits
* in the bitmap.
*
* Set the bit of the entry if it's been modified (obviously
* should be backed up) plus its parent directory.
*
* If the entry is a directory and is not modified itself,
* but it's marked, then there is something below it that
* is being backed up. It shows the the path, leads to
* an object that will be backed up. So the path should
* be marked too.
*
* The backup path itself is always marked.
*
* Parameters:
* arg (input) - pointer to the mark parameter
* pnp (input) - pointer to the path node
* enp (input) - pointer to the entry node
*
* Returns:
* 0: as long as traversing should continue
* != 0: if traversing should stop
*/
int
mark_cb(void *arg, fst_node_t *pnp, fst_node_t *enp)
{
int bmd;
int rv;
u_longlong_t bl;
time_t ddate;
fs_fhandle_t *pfhp, *efhp;
struct stat64 *pstp, *estp;
mark_param_t *mpp;
ndmp_lbr_params_t *nlp;
tlm_acls_t *tacl;
rv = 0;
mpp = (mark_param_t *)arg;
tacl = mpp->mp_tacl;
nlp = ndmp_get_nlp(mpp->mp_session);
if (!mpp) {
syslog(LOG_ERR, "NULL argument passed");
rv = -1;
} else if (mpp->mp_session->ns_eof) {
syslog(LOG_INFO, "Connection to the client is closed");
rv = -1;
} else if (mpp->mp_session->ns_data.dd_abort ||
(nlp && NLP_ISSET(nlp, NLPF_ABORTED))) {
syslog(LOG_INFO, "Processing directories aborted.");
rv = -1;
}
if (rv != 0)
return (rv);
ddate = mpp->mp_ddate;
bmd = mpp->mp_bmd;
bl = dbm_getlen(bmd);
pfhp = pnp->tn_fh;
pstp = pnp->tn_st;
/* sanity check on fh and stat of the path passed */
if (pstp->st_ino > bl) {
syslog(LOG_ERR, "Invalid path inode #%u",
(uint_t)pstp->st_ino);
return (-1);
}
if (pstp->st_ino != pfhp->fh_fid) {
syslog(LOG_ERR, "Path ino mismatch %u %u",
(uint_t)pstp->st_ino, (uint_t)pfhp->fh_fid);
return (-1);
}
/*
* Always mark the backup path inode number.
*/
if (!enp->tn_path) {
(void) dbm_setone(bmd, pstp->st_ino);
return (0);
}
efhp = enp->tn_fh;
estp = enp->tn_st;
/* sanity check on fh and stat of the entry passed */
if (estp->st_ino > bl) {
syslog(LOG_ERR, "Invalid entry inode #%u",
(uint_t)estp->st_ino);
return (-1);
}
if (estp->st_ino != efhp->fh_fid) {
syslog(LOG_ERR, "Entry ino mismatch %u %u", estp->st_ino,
(uint_t)pfhp->fh_fid);
return (-1);
}
/* check the dates and mark the bitmap inode */
if (ddate == 0) {
/* base backup */
(void) dbm_setone(bmd, (u_longlong_t)estp->st_ino);
(void) dbm_setone(bmd, (u_longlong_t)pstp->st_ino);
} else if (estp->st_mtime > ddate) {
(void) dbm_setone(bmd, (u_longlong_t)estp->st_ino);
(void) dbm_setone(bmd, (u_longlong_t)pstp->st_ino);
if (ndmpd_verbose_traverse) {
syslog(LOG_DEBUG,
"m(%u,%u,%u,%u)", (uint_t)pstp->st_ino,
(uint_t)estp->st_ino, (uint_t)estp->st_mtime,
(uint_t)ddate);
syslog(LOG_DEBUG, "\"%s/%s\"",
pnp->tn_path, enp->tn_path);
}
} else if (iscreated(nlp, NULL, tacl, ddate)) {
(void) dbm_setone(bmd, (u_longlong_t)estp->st_ino);
(void) dbm_setone(bmd, (u_longlong_t)pstp->st_ino);
if (ndmpd_verbose_traverse) {
syslog(LOG_DEBUG,
"cr(%u,%u,%u,%u)", (uint_t)pstp->st_ino,
(uint_t)estp->st_ino, (uint_t)estp->st_mtime,
(uint_t)ddate);
syslog(LOG_DEBUG, "\"%s/%s\"",
pnp->tn_path, enp->tn_path);
}
} else if (estp->st_ctime > ddate) {
if (!NLP_IGNCTIME(nlp)) {
(void) dbm_setone(bmd, (u_longlong_t)estp->st_ino);
(void) dbm_setone(bmd, (u_longlong_t)pstp->st_ino);
}
if (ndmpd_verbose_traverse) {
if (NLP_IGNCTIME(nlp)) {
syslog(LOG_DEBUG,
"ign c(%u,%u,%u,%u)", (uint_t)pstp->st_ino,
(uint_t)estp->st_ino,
(uint_t)estp->st_ctime, (uint_t)ddate);
} else {
syslog(LOG_DEBUG,
"c(%u,%u,%u,%u)", (uint_t)pstp->st_ino,
(uint_t)estp->st_ino,
(uint_t)estp->st_ctime, (uint_t)ddate);
}
syslog(LOG_DEBUG, "\"%s/%s\"",
pnp->tn_path, enp->tn_path);
}
} else if (S_ISDIR(estp->st_mode) &&
dbm_getone(bmd, (u_longlong_t)estp->st_ino)) {
(void) dbm_setone(bmd, (u_longlong_t)pstp->st_ino);
}
return (0);
}
/*
* ndmpd_fhdir_v3_cb
*
* Callback function for file history dir information
*/
int
ndmpd_fhdir_v3_cb(lbr_fhlog_call_backs_t *cbp, char *dir, struct stat64 *stp)
{
char nm[PATH_MAX+1];
int nml;
int err;
ulong_t ino, pino;
ulong_t pos;
ndmp_lbr_params_t *nlp;
ndmpd_module_params_t *params;
DIR *dirp;
char dirpath[PATH_MAX];
if (!cbp) {
err = -1;
syslog(LOG_DEBUG, "cbp is NULL");
} else if (!cbp->fh_cookie) {
err = -1;
syslog(LOG_DEBUG, "cookie is NULL");
} else if (!dir) {
err = -1;
syslog(LOG_DEBUG, "dir is NULL");
} else if (!(nlp = ndmp_get_nlp(cbp->fh_cookie))) {
err = -1;
syslog(LOG_DEBUG, "nlp is NULL");
} else
err = 0;
if (err != 0)
return (0);
if (!NLP_ISSET(nlp, NLPF_FH))
return (0);
/*
* Veritas net_backup accepts only 2 as the inode number of the backup
* root directory. The other way compares the path against the
* backup path which is slower.
*/
if (stp->st_ino == nlp->nlp_bkdirino)
pino = ROOT_INODE;
else
pino = stp->st_ino;
/*
* There is nothing below this directory to be backed up.
* If there was, the bit for this directory would have
* been set. Backup root directory is exception. We
* always send the dir file history records of it.
*/
if (pino != ROOT_INODE &&
!dbm_getone(nlp->nlp_bkmap, (u_longlong_t)stp->st_ino)) {
syslog(LOG_DEBUG, "nothing below here");
return (0);
}
params = nlp->nlp_params;
if (!params || !params->mp_file_history_dir_func)
return (-1);
pos = 0;
err = 0;
dirp = opendir(dir);
if (dirp == NULL)
return (0);
do {
nml = PATH_MAX;
err = dp_readdir(dirp, &pos, nm, &nml, &ino);
if (err != 0) {
syslog(LOG_DEBUG,
"%d reading pos %u dir \"%s\"", err, pos, dir);
break;
}
if (nml == 0)
break;
nm[nml] = '\0';
if (pino == ROOT_INODE) {
if (rootfs_dot_or_dotdot(nm))
ino = ROOT_INODE;
} else if (ino == nlp->nlp_bkdirino && IS_DOTDOT(nm)) {
ino = ROOT_INODE;
}
if (!dbm_getone(nlp->nlp_bkmap, (u_longlong_t)ino))
continue;
/*
* If the entry is on exclusion list dont send the info
*/
if (tlm_is_excluded(dir, nm, ndmp_excl_list)) {
syslog(LOG_DEBUG,
"name \"%s\" skipped", nm == 0 ? "nil" : nm);
continue;
}
err = (*params->mp_file_history_dir_func)(cbp->fh_cookie, nm,
ino, pino);
if (err < 0) {
syslog(LOG_ERR, "\"%s\": %d", dir, err);
break;
}
/*
* This is a requirement by some DMA's (net_vault) that during
* the incremental backup, the node info should also be sent
* along with the dir info for all directories leading to a
* backed up file.
*/
if (ndmp_fhinode) {
struct stat64 ret_attr;
(void) strlcpy(dirpath, dir, PATH_MAX);
(void) strlcat(dirpath, "/", PATH_MAX);
(void) strlcat(dirpath, nm, PATH_MAX);
err = stat64(dirpath, &ret_attr);
if (err != 0) {
syslog(LOG_ERR,
"Error looking up %s", nm);
break;
}
if (S_ISDIR(ret_attr.st_mode)) {
err = (*params->mp_file_history_node_func)(cbp->
fh_cookie, ino, &ret_attr, 0);
if (err < 0) {
syslog(LOG_ERR, "\"%s/\": %d",
dir, err);
break;
}
}
}
} while (err == 0);
(void) closedir(dirp);
return (err);
}
/*
* marklbrv3_cb
*
* The callback function, called by traverse_post to mark
* bits in the bitmap.
*
* It's so much like mark_cb for time-based (token-based
* and level-type) backup types, except that it looks at
* the archive bit of the objects instead of their timestamp.
*
* Parameters:
* arg (input) - pointer to the mark parameter
* pnp (input) - pointer to the path node
* enp (input) - pointer to the entry node
*
* Returns:
* 0: as long as traversing should continue
* != 0: if traversing should stop
*/
int
marklbrv3_cb(void *arg, fst_node_t *pnp, fst_node_t *enp)
{
int bmd;
u_longlong_t bl;
fs_fhandle_t *pfhp, *efhp;
struct stat64 *pstp, *estp;
mark_param_t *mpp;
ndmp_lbr_params_t *nlp;
mpp = (mark_param_t *)arg;
if (!mpp) {
syslog(LOG_ERR, "NULL argument passed in marklbrv3");
return (-1);
}
nlp = ndmp_get_nlp(mpp->mp_session);
if (mpp->mp_session->ns_data.dd_abort ||
(nlp && NLP_ISSET(nlp, NLPF_ABORTED))) {
syslog(LOG_ERR, "Processing directories aborted.");
return (-1);
}
bmd = mpp->mp_bmd;
bl = dbm_getlen(bmd);
pfhp = pnp->tn_fh;
pstp = pnp->tn_st;
/* sanity check on fh and stat of the path passed */
if (pstp->st_ino > bl) {
syslog(LOG_ERR, "Invalid path inode #%u",
(uint_t)pstp->st_ino);
return (-1);
}
if (pstp->st_ino != pfhp->fh_fid) {
syslog(LOG_ERR, "Path ino mismatch %u %u",
(uint_t)pstp->st_ino, (uint_t)pfhp->fh_fid);
return (-1);
}
/*
* Always mark the backup path inode number.
*/
if (!enp->tn_path) {
(void) dbm_setone(bmd, pstp->st_ino);
return (0);
}
efhp = enp->tn_fh;
estp = enp->tn_st;
/* sanity check on fh and stat of the entry passed */
if (estp->st_ino > bl) {
syslog(LOG_DEBUG, "Invalid entry inode #%u",
(uint_t)estp->st_ino);
return (-1);
}
if (estp->st_ino != efhp->fh_fid) {
syslog(LOG_DEBUG, "Entry ino mismatch %u %u", estp->st_ino,
(uint_t)pfhp->fh_fid);
return (-1);
}
if (S_ISDIR(estp->st_mode) &&
dbm_getone(bmd, (u_longlong_t)estp->st_ino)) {
(void) dbm_setone(bmd, (u_longlong_t)pstp->st_ino);
}
return (0);
}
/*
* ndmpd_tar_backup_starter (V2 only)
*
* The main backup starter function. It creates a snapshot if necessary
* and calls ndmp_tar_backup to perform the actual backup. It does the cleanup
* and release the snapshot at the end.
*/
int
ndmpd_tar_backup_starter(void *arg)
{
ndmpd_module_params_t *mod_params = arg;
int err;
ndmpd_session_t *session;
ndmp_lbr_params_t *nlp;
session = (ndmpd_session_t *)(mod_params->mp_daemon_cookie);
*(mod_params->mp_module_cookie) = nlp = ndmp_get_nlp(session);
ndmp_session_ref(session);
err = 0;
if (fs_is_chkpntvol(nlp->nlp_backup_path) ||
fs_is_rdonly(nlp->nlp_backup_path) ||
!fs_is_chkpnt_enabled(nlp->nlp_backup_path))
NLP_SET(nlp, NLPF_CHKPNTED_PATH);
else {
NLP_UNSET(nlp, NLPF_CHKPNTED_PATH);
if (ndmp_create_snapshot(nlp->nlp_backup_path,
nlp->nlp_jstat->js_job_name) < 0) {
MOD_LOG(mod_params,
"Error: creating checkpoint on %s\n",
nlp->nlp_backup_path);
/* -1 causes halt reason to become internal error. */
err = -1;
}
}
NDMP_LOG(LOG_DEBUG, "NLPF_CHKPNTED_PATH: %c",
NDMP_YORN(NLP_ISCHKPNTED(nlp)));
NDMP_LOG(LOG_DEBUG, "err: %d, update %c",
err, NDMP_YORN(NLP_SHOULD_UPDATE(nlp)));
if (err == 0) {
err = ndmp_get_cur_bk_time(nlp, &nlp->nlp_cdate,
nlp->nlp_jstat->js_job_name);
if (err != 0) {
NDMP_LOG(LOG_DEBUG, "err %d", err);
} else {
log_bk_params_v2(session, mod_params, nlp);
err = ndmpd_tar_backup(session, mod_params, nlp);
}
}
if (nlp->nlp_bkmap >= 0) {
(void) dbm_free(nlp->nlp_bkmap);
nlp->nlp_bkmap = -1;
}
if (!NLP_ISCHKPNTED(nlp))
(void) ndmp_remove_snapshot(nlp->nlp_backup_path,
nlp->nlp_jstat->js_job_name);
NDMP_LOG(LOG_DEBUG, "err %d, update %c",
err, NDMP_YORN(NLP_SHOULD_UPDATE(nlp)));
if (err == 0 && NLP_SHOULD_UPDATE(nlp)) {
if (ndmpd_put_dumptime(nlp->nlp_backup_path, nlp->nlp_clevel,
nlp->nlp_cdate) < 0) {
err = EPERM;
MOD_LOG(mod_params,
"Error: updating the dumpdates file on %s\n",
nlp->nlp_backup_path);
}
}
MOD_DONE(mod_params, err);
/* nlp_params is allocated in start_backup() */
NDMP_FREE(nlp->nlp_params);
NS_DEC(nbk);
ndmp_session_unref(session);
return (err);
}
/*
* ndmp_restore_extract_params
*
* Go through the restore parameters and check them and extract them
* by setting NLP flags and other values.
*
* Parameters:
*
* Returns:
* 0: on success
* -1: otherwise
*/
int
ndmp_restore_extract_params(ndmpd_session_t *session,
ndmpd_module_params_t *params)
{
char *bkpath, *rspath;
ndmp_lbr_params_t *nlp;
if ((nlp = ndmp_get_nlp(session)) == NULL) {
NDMP_LOG(LOG_DEBUG, "nlp == NULL");
return (-1);
}
/* Extract directory from where the backup was made. */
if ((bkpath = get_backup_path_v2(params)) == NULL)
return (NDMP_ILLEGAL_ARGS_ERR);
nlp->nlp_restore_bk_path = bkpath;
/* The number of the selections. */
if ((nlp->nlp_nfiles = get_nfiles(session, params)) == 0)
return (NDMP_ILLEGAL_ARGS_ERR);
NDMP_LOG(LOG_DEBUG, "nfiles: %d", nlp->nlp_nfiles);
if ((rspath = get_restore_dest(params)) == NULL)
return (NDMP_ILLEGAL_ARGS_ERR);
if (fs_is_rdonly(rspath)) {
MOD_LOG(params,
"Error: Can't restore to a read-only volume: \"%s\"\n",
rspath);
return (NDMP_ILLEGAL_ARGS_ERR);
}
if (fs_is_chkpntvol(rspath)) {
MOD_LOG(params,
"Error: Can't restore to a checkpoint: \"%s\"\n", rspath);
return (NDMP_ILLEGAL_ARGS_ERR);
}
if (same_path(bkpath, rspath))
rspath = "";
if ((nlp->nlp_restore_path = strdup(rspath)) == NULL)
return (NDMP_NO_MEM_ERR);
bkpath = trim_name(bkpath);
if (correct_ents(params, nlp->nlp_nfiles, bkpath) < 0) {
free(nlp->nlp_restore_path);
return (NDMP_ILLEGAL_ARGS_ERR);
}
if (check_restore_paths(params, nlp->nlp_nfiles, rspath) < 0) {
free(nlp->nlp_restore_path);
return (NDMP_ILLEGAL_ARGS_ERR);
}
MOD_LOG(params, "Restoring %d files.\n", nlp->nlp_nfiles);
MOD_LOG(params, "Restoring to: \"%s\".\n", nlp->nlp_restore_path);
MOD_LOG(params, "Record size: %d\n", session->ns_mover.md_record_size);
return (NDMP_NO_ERR);
}
/*
* ndmp_backup_extract_params
*
* Go through the backup parameters and check the validity
* for each one. Then set the NLP flags according to the parameters.
*/
int
ndmp_backup_extract_params(ndmpd_session_t *session,
ndmpd_module_params_t *params)
{
char *cp;
int rv;
ndmp_lbr_params_t *nlp;
/* Extract directory to be backed up from env variables */
if ((nlp = ndmp_get_nlp(session)) == NULL) {
MOD_LOG(params, "Error: Internal error: nlp == NULL.\n");
return (NDMP_ILLEGAL_ARGS_ERR);
}
if ((nlp->nlp_backup_path = get_backup_path_v2(params)) == NULL)
return (NDMP_FILE_NOT_FOUND_ERR);
if ((rv = check_backup_dir_validity(params,
nlp->nlp_backup_path)) != NDMP_NO_ERR)
return (rv);
/* Should the st_ctime be ignored when backing up? */
if (ndmp_ignore_ctime) {
NDMP_LOG(LOG_DEBUG, "ignoring st_ctime");
NLP_SET(nlp, NLPF_IGNCTIME);
} else
NLP_UNSET(nlp, NLPF_IGNCTIME);
/* Should the st_lmtime be ignored when backing up? */
if (ndmp_include_lmtime) {
NDMP_LOG(LOG_DEBUG, "including st_lmtime");
NLP_SET(nlp, NLPF_INCLMTIME);
} else
NLP_UNSET(nlp, NLPF_INCLMTIME);
NDMP_LOG(LOG_DEBUG, "flags %x", nlp->nlp_flags);
/* Is backup history requested? */
cp = MOD_GETENV(params, "HIST");
if (cp == NULL) {
NDMP_LOG(LOG_DEBUG, "env(HIST) not specified");
NLP_UNSET(nlp, NLPF_FH);
} else {
NDMP_LOG(LOG_DEBUG, "env(HIST): \"%s\"", cp);
if (strchr("t_ty_y", *cp))
NLP_SET(nlp, NLPF_FH);
else
NLP_UNSET(nlp, NLPF_FH);
}
nlp->nlp_clevel = 0;
/* Is it an incremental backup? */
cp = MOD_GETENV(params, "LEVEL");
if (cp == NULL) {
NDMP_LOG(LOG_DEBUG,
"env(LEVEL) not specified, default to 0");
} else if (*cp < '0' || *cp > '9' || *(cp+1) != '\0') {
NDMP_LOG(LOG_DEBUG, "Invalid backup level '%s'", cp);
return (NDMP_ILLEGAL_ARGS_ERR);
} else
nlp->nlp_clevel = *cp - '0';
/* Extract last backup time from the dumpdates file */
nlp->nlp_llevel = nlp->nlp_clevel;
nlp->nlp_ldate = 0;
if (ndmpd_get_dumptime(nlp->nlp_backup_path, &nlp->nlp_llevel,
&nlp->nlp_ldate) < 0) {
MOD_LOG(params, "Error: getting dumpdate for %s level %d\n",
nlp->nlp_backup_path, nlp->nlp_clevel);
return (NDMP_NO_MEM_ERR);
}
NDMP_LOG(LOG_DEBUG,
"Date of this level %d on \"%s\": %s",
nlp->nlp_clevel, nlp->nlp_backup_path, cctime(&nlp->nlp_cdate));
NDMP_LOG(LOG_DEBUG,
"Date of last level %d on \"%s\": %s",
nlp->nlp_llevel, nlp->nlp_backup_path, cctime(&nlp->nlp_ldate));
/* Should the dumpdate file be updated? */
cp = MOD_GETENV(params, "UPDATE");
if (cp == NULL) {
NDMP_LOG(LOG_DEBUG,
"env(UPDATE) not specified, default to TRUE");
NLP_SET(nlp, NLPF_UPDATE);
} else {
NDMP_LOG(LOG_DEBUG, "env(UPDATE): \"%s\"", cp);
if (strchr("t_ty_y", *cp) != NULL)
NLP_SET(nlp, NLPF_UPDATE);
else
NLP_UNSET(nlp, NLPF_UPDATE);
}
return (NDMP_NO_ERR);
}
