xref: /illumos-gate/usr/src/cmd/ndmpd/ndmp/ndmpd_tar.c (revision 2654012f83cec5dc15b61dfe3e4a4915f186e7a6)
1 /*
2  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 /*
7  * BSD 3 Clause License
8  *
9  * Copyright (c) 2007, The Storage Networking Industry Association.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 	- Redistributions of source code must retain the above copyright
15  *	  notice, this list of conditions and the following disclaimer.
16  *
17  * 	- Redistributions in binary form must reproduce the above copyright
18  *	  notice, this list of conditions and the following disclaimer in
19  *	  the documentation and/or other materials provided with the
20  *	  distribution.
21  *
22  *	- Neither the name of The Storage Networking Industry Association (SNIA)
23  *	  nor the names of its contributors may be used to endorse or promote
24  *	  products derived from this software without specific prior written
25  *	  permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37  * POSSIBILITY OF SUCH DAMAGE.
38  */
39 /* Copyright (c) 1996, 1997 PDC, Network Appliance. All Rights Reserved */
40 
41 #include <sys/stat.h>
42 #include <sys/types.h>
43 #include <sys/socket.h>
44 #include <errno.h>
45 #include <stdio.h>
46 #include <string.h>
47 #include <unistd.h>
48 #include <time.h>
49 #include <cstack.h>
50 #include <dirent.h>
51 #include <traverse.h>
52 #include "bitmap.h"
53 #include "ndmpd.h"
54 #include "tlm_buffers.h"
55 
56 
57 typedef struct ndmp_run_args {
58 	char *nr_chkp_nm;
59 	char *nr_unchkp_nm;
60 	char **nr_excls;
61 } ndmp_run_args_t;
62 
63 
64 /*
65  * backup_create_structs
66  *
67  * Allocate the structures before performing backup
68  *
69  * Parameters:
70  *   sesison (input) - session handle
71  *   jname (input) - backup job name
72  *
73  * Returns:
74  *   0: on success
75  *  -1: otherwise
76  */
77 static int
78 backup_create_structs(ndmpd_session_t *session, char *jname)
79 {
80 	int n;
81 	long xfer_size;
82 	ndmp_lbr_params_t *nlp;
83 	tlm_commands_t *cmds;
84 
85 	if ((nlp = ndmp_get_nlp(session)) == NULL) {
86 		NDMP_LOG(LOG_DEBUG, "nlp == NULL");
87 		return (-1);
88 	}
89 
90 	if ((nlp->nlp_jstat = tlm_new_job_stats(jname)) == NULL) {
91 		NDMP_LOG(LOG_DEBUG, "Creating job stats");
92 		return (-1);
93 	}
94 
95 	cmds = &nlp->nlp_cmds;
96 	(void) memset(cmds, 0, sizeof (*cmds));
97 
98 	xfer_size = ndmp_buffer_get_size(session);
99 	if (xfer_size < 512*KILOBYTE) {
100 		/*
101 		 * Read multiple of mover_record_size near to 512K.  This
102 		 * will prevent the data being copied in the mover buffer
103 		 * when we write the data.
104 		 */
105 		if ((n = (512 * KILOBYTE/xfer_size)) <= 0)
106 			n = 1;
107 		xfer_size *= n;
108 		NDMP_LOG(LOG_DEBUG, "Adjusted read size: %d", xfer_size);
109 	}
110 
111 	cmds->tcs_command = tlm_create_reader_writer_ipc(TRUE, xfer_size);
112 	if (cmds->tcs_command == NULL) {
113 		NDMP_LOG(LOG_DEBUG, "Error creating ipc buffers");
114 		tlm_un_ref_job_stats(jname);
115 		return (-1);
116 	}
117 
118 	nlp->nlp_logcallbacks = lbrlog_callbacks_init(session,
119 	    ndmpd_file_history_path,
120 	    ndmpd_file_history_dir,
121 	    ndmpd_file_history_node);
122 	if (nlp->nlp_logcallbacks == NULL) {
123 		tlm_release_reader_writer_ipc(cmds->tcs_command);
124 		tlm_un_ref_job_stats(jname);
125 		return (-1);
126 	}
127 	nlp->nlp_jstat->js_callbacks = (void *)(nlp->nlp_logcallbacks);
128 
129 	return (0);
130 }
131 
132 
133 /*
134  * restore_create_structs
135  *
136  * Allocate structures for performing a restore
137  *
138  * Parameters:
139  *   sesison (input) - session handle
140  *   jname (input) - backup job name
141  *
142  * Returns:
143  *   0: on success
144  *  -1: otherwise
145  */
146 static int
147 restore_create_structs(ndmpd_session_t *session, char *jname)
148 {
149 	int i;
150 	long xfer_size;
151 	ndmp_lbr_params_t *nlp;
152 	tlm_commands_t *cmds;
153 
154 	if ((nlp = ndmp_get_nlp(session)) == NULL) {
155 		NDMP_LOG(LOG_DEBUG, "nlp == NULL");
156 		return (-1);
157 	}
158 	if ((nlp->nlp_jstat = tlm_new_job_stats(jname)) == NULL) {
159 		NDMP_LOG(LOG_DEBUG, "Creating job stats");
160 		return (-1);
161 	}
162 
163 	cmds = &nlp->nlp_cmds;
164 	(void) memset(cmds, 0, sizeof (*cmds));
165 
166 	xfer_size = ndmp_buffer_get_size(session);
167 	cmds->tcs_command = tlm_create_reader_writer_ipc(FALSE, xfer_size);
168 	if (cmds->tcs_command == NULL) {
169 		NDMP_LOG(LOG_DEBUG, "Error creating ipc buffers");
170 		tlm_un_ref_job_stats(jname);
171 		return (-1);
172 	}
173 
174 	nlp->nlp_logcallbacks = lbrlog_callbacks_init(session,
175 	    ndmpd_path_restored, NULL, NULL);
176 	if (nlp->nlp_logcallbacks == NULL) {
177 		tlm_release_reader_writer_ipc(cmds->tcs_command);
178 		tlm_un_ref_job_stats(jname);
179 		return (-1);
180 	}
181 	nlp->nlp_jstat->js_callbacks = (void *)(nlp->nlp_logcallbacks);
182 
183 	nlp->nlp_restored = ndmp_malloc(sizeof (boolean_t) * nlp->nlp_nfiles);
184 	if (nlp->nlp_restored == NULL) {
185 		lbrlog_callbacks_done(nlp->nlp_logcallbacks);
186 		tlm_release_reader_writer_ipc(cmds->tcs_command);
187 		tlm_un_ref_job_stats(jname);
188 		return (-1);
189 	}
190 	for (i = 0; i < (int)nlp->nlp_nfiles; i++)
191 		nlp->nlp_restored[i] = FALSE;
192 
193 	return (0);
194 }
195 
196 
197 /*
198  * send_unrecovered_list
199  *
200  * Creates a list of restored files
201  *
202  * Parameters:
203  *   params (input) - NDMP parameters
204  *   nlp (input) - NDMP/LBR parameters
205  *
206  * Returns:
207  *   0: on success
208  *  -1: otherwise
209  */
210 static int
211 send_unrecovered_list(ndmpd_module_params_t *params, ndmp_lbr_params_t *nlp)
212 {
213 	int i, rv;
214 	ndmp_name *ent;
215 
216 	if (params == NULL) {
217 		NDMP_LOG(LOG_DEBUG, "params == NULL");
218 		return (-1);
219 	}
220 	if (nlp == NULL) {
221 		NDMP_LOG(LOG_DEBUG, "nlp == NULL");
222 		return (-1);
223 	}
224 
225 	rv = 0;
226 	for (i = 0; i < (int)nlp->nlp_nfiles; i++) {
227 		NDMP_LOG(LOG_DEBUG, "nlp->nlp_restored[%d]: %s", i,
228 		    nlp->nlp_restored[i] ? "TRUE" : "FALSE");
229 
230 		if (!nlp->nlp_restored[i]) {
231 			ent = (ndmp_name *)MOD_GETNAME(params, i);
232 			if (ent == NULL) {
233 				NDMP_LOG(LOG_DEBUG, "ent == NULL");
234 				rv = -1;
235 				break;
236 			}
237 			if (ent->name == NULL) {
238 				NDMP_LOG(LOG_DEBUG, "ent->name == NULL");
239 				rv = -1;
240 				break;
241 			}
242 
243 			NDMP_LOG(LOG_DEBUG, "ent.name: \"%s\"", ent->name);
244 
245 			rv = MOD_FILERECOVERD(params, ent->name, ENOENT);
246 			if (rv < 0)
247 				break;
248 		}
249 	}
250 
251 	return (rv);
252 }
253 
254 
255 /*
256  * backup_release_structs
257  *
258  * Deallocated the NDMP/LBR specific parameters
259  *
260  * Parameters:
261  *   session (input) - session handle
262  *
263  * Returns:
264  *   void
265  */
266 /*ARGSUSED*/
267 static void
268 backup_release_structs(ndmpd_session_t *session)
269 {
270 	ndmp_lbr_params_t *nlp;
271 	tlm_commands_t *cmds;
272 
273 	if ((nlp = ndmp_get_nlp(session)) == NULL) {
274 		NDMP_LOG(LOG_DEBUG, "nlp == NULL");
275 		return;
276 	}
277 	cmds = &nlp->nlp_cmds;
278 	if (cmds == NULL) {
279 		NDMP_LOG(LOG_DEBUG, "cmds == NULL");
280 		return;
281 	}
282 
283 	if (nlp->nlp_logcallbacks != NULL) {
284 		lbrlog_callbacks_done(nlp->nlp_logcallbacks);
285 		nlp->nlp_logcallbacks = NULL;
286 	} else {
287 		NDMP_LOG(LOG_DEBUG, "FH CALLBACKS == NULL");
288 	}
289 
290 	if (cmds->tcs_command != NULL) {
291 		if (cmds->tcs_command->tc_buffers != NULL)
292 			tlm_release_reader_writer_ipc(cmds->tcs_command);
293 		else
294 			NDMP_LOG(LOG_DEBUG, "BUFFERS == NULL");
295 		cmds->tcs_command = NULL;
296 	} else {
297 		NDMP_LOG(LOG_DEBUG, "COMMAND == NULL");
298 	}
299 
300 	if (nlp->nlp_bkmap >= 0) {
301 		(void) dbm_free(nlp->nlp_bkmap);
302 		nlp->nlp_bkmap = -1;
303 	}
304 
305 	if (session->ns_data.dd_operation == NDMP_DATA_OP_RECOVER &&
306 	    nlp->nlp_restored != NULL) {
307 		free(nlp->nlp_restored);
308 		nlp->nlp_restored = NULL;
309 	} else {
310 		NDMP_LOG(LOG_DEBUG, "nlp_restored == NULL");
311 	}
312 }
313 
314 /*
315  * ndmp_write_utf8magic
316  *
317  * Write a magic pattern to the tar header. This is used
318  * as a crest to indicate that tape belongs to us.
319  */
320 int
321 ndmp_write_utf8magic(tlm_cmd_t *cmd)
322 {
323 	char *cp;
324 	long actual_size;
325 
326 	if (cmd->tc_buffers == NULL) {
327 		NDMP_LOG(LOG_DEBUG, "cmd->tc_buffers == NULL");
328 		return (-1);
329 	}
330 
331 	cp = tlm_get_write_buffer(RECORDSIZE, &actual_size,
332 	    cmd->tc_buffers, TRUE);
333 	if (actual_size < RECORDSIZE) {
334 		NDMP_LOG(LOG_DEBUG, "Couldn't get enough buffer");
335 		return (-1);
336 	}
337 
338 	(void) strlcpy(cp, NDMPUTF8MAGIC, RECORDSIZE);
339 	return (0);
340 }
341 
342 
343 /*
344  * timecmp
345  *
346  * This callback function is used during backup.  It checks
347  * if the object specified by the 'attr' should be backed
348  * up or not.
349  *
350  * Directories are backed up anyways for dump format.
351  * If this function is called, then the directory is
352  * marked in the bitmap vector, it shows that either the
353  * directory itself is modified or there is something below
354  * it that will be backed up.
355  *
356  * Directories for tar format are backed up if and only if
357  * they are modified.
358  *
359  * By setting ndmp_force_bk_dirs global variable to a non-zero
360  * value, directories are backed up anyways.
361  *
362  * Backing up the directories unconditionally, helps
363  * restoring the metadata of directories as well, when one
364  * of the objects below them are being restored.
365  *
366  * For non-directory objects, if the modification or change
367  * time of the object is after the date specified by the
368  * bk_selector_t, the the object must be backed up.
369  *
370  */
371 static boolean_t
372 timecmp(bk_selector_t *bksp,
373 		struct stat64 *attr)
374 {
375 	ndmp_lbr_params_t *nlp;
376 
377 	nlp = (ndmp_lbr_params_t *)bksp->bs_cookie;
378 	if (S_ISDIR(attr->st_mode) && ndmp_force_bk_dirs) {
379 		NDMP_LOG(LOG_DEBUG, "d(%lu)",
380 		    (uint_t)attr->st_ino);
381 		return (TRUE);
382 	}
383 	if (S_ISDIR(attr->st_mode) &&
384 	    dbm_getone(nlp->nlp_bkmap, (u_longlong_t)attr->st_ino) &&
385 	    ((NLP_ISDUMP(nlp) && ndmp_dump_path_node) ||
386 	    (NLP_ISTAR(nlp) && ndmp_tar_path_node))) {
387 		/*
388 		 * If the object is a directory and it leads to a modified
389 		 * object (that should be backed up) and for that type of
390 		 * backup the path nodes should be backed up, then return
391 		 * TRUE.
392 		 *
393 		 * This is required by some DMAs like Backup Express, which
394 		 * needs to receive ADD_NODE (for dump) or ADD_PATH (for tar)
395 		 * for the intermediate directories of a modified object.
396 		 * Other DMAs, like net_backup and net_worker, do not have such
397 		 * requirement.  This requirement makes sense for dump format
398 		 * but for 'tar' format, it does not.  In provision to the
399 		 * NDMP-v4 spec, for 'tar' format the intermediate directories
400 		 * need not to be reported.
401 		 */
402 		NDMP_LOG(LOG_DEBUG, "p(%lu)", (u_longlong_t)attr->st_ino);
403 		return (TRUE);
404 	}
405 	if (attr->st_mtime > bksp->bs_ldate) {
406 		NDMP_LOG(LOG_DEBUG, "m(%lu): %lu > %lu",
407 		    (uint_t)attr->st_ino, (uint_t)attr->st_mtime,
408 		    (uint_t)bksp->bs_ldate);
409 		return (TRUE);
410 	}
411 	if (attr->st_ctime > bksp->bs_ldate) {
412 		if (NLP_IGNCTIME(nlp)) {
413 			NDMP_LOG(LOG_DEBUG, "ign c(%lu): %lu > %lu",
414 			    (uint_t)attr->st_ino, (uint_t)attr->st_ctime,
415 			    (uint_t)bksp->bs_ldate);
416 			return (FALSE);
417 		}
418 		NDMP_LOG(LOG_DEBUG, "c(%lu): %lu > %lu",
419 		    (uint_t)attr->st_ino, (uint_t)attr->st_ctime,
420 		    (uint_t)bksp->bs_ldate);
421 		return (TRUE);
422 	}
423 	NDMP_LOG(LOG_DEBUG, "mc(%lu): (%lu,%lu) < %lu",
424 	    (uint_t)attr->st_ino, (uint_t)attr->st_mtime,
425 	    (uint_t)attr->st_ctime, (uint_t)bksp->bs_ldate);
426 	return (FALSE);
427 }
428 
429 
430 /*
431  * get_acl_info
432  *
433  * load up all the access and attribute info
434  */
435 static int
436 get_acl_info(char *name, tlm_acls_t *tlm_acls)
437 {
438 	int erc;
439 	acl_t *aclp = NULL;
440 	char *acltp;
441 
442 	erc = lstat64(name, &tlm_acls->acl_attr);
443 	if (erc != 0) {
444 		NDMP_LOG(LOG_ERR, "Could not find file %s.", name);
445 		erc = TLM_NO_SOURCE_FILE;
446 		return (erc);
447 	}
448 	erc = acl_get(name, ACL_NO_TRIVIAL, &aclp);
449 	if (erc != 0) {
450 		NDMP_LOG(LOG_DEBUG,
451 		    "Could not read ACL for file [%s]", name);
452 		erc = TLM_NO_SOURCE_FILE;
453 		return (erc);
454 	}
455 	if (aclp && (acltp = acl_totext(aclp,
456 	    ACL_APPEND_ID | ACL_SID_FMT | ACL_COMPACT_FMT)) != NULL) {
457 		(void) strlcpy(tlm_acls->acl_info.attr_info, acltp,
458 		    TLM_MAX_ACL_TXT);
459 		acl_free(aclp);
460 		free(acltp);
461 	}
462 	return (erc);
463 }
464 /*
465  * get_dir_acl_info
466  *
467  * load up all ACL and attr info about a directory
468  */
469 static int
470 get_dir_acl_info(char *dir, tlm_acls_t *tlm_acls, tlm_job_stats_t *js)
471 {
472 	int	erc;
473 	char	*checkpointed_dir;
474 	char	root_dir[TLM_VOLNAME_MAX_LENGTH];
475 	char	*spot;
476 	char	*fil;
477 	acl_t	*aclp = NULL;
478 	char 	*acltp;
479 
480 	checkpointed_dir = ndmp_malloc(TLM_MAX_PATH_NAME);
481 	if (checkpointed_dir == NULL)
482 		return (-1);
483 
484 	if (tlm_acls->acl_checkpointed)
485 		fil = tlm_build_snapshot_name(dir, checkpointed_dir,
486 		    js->js_job_name);
487 	else
488 		fil = dir;
489 	erc = lstat64(fil, &tlm_acls->acl_attr);
490 	if (erc != 0) {
491 		NDMP_LOG(LOG_ERR, "Could not find directory %s.", dir);
492 		free(checkpointed_dir);
493 		return (-1);
494 	}
495 
496 	spot = strchr(&fil[1], '/');
497 	if (spot == NULL) {
498 		(void) strlcpy(root_dir, fil, TLM_VOLNAME_MAX_LENGTH);
499 	} else {
500 		*spot = 0;
501 		(void) strlcpy(root_dir, fil, TLM_VOLNAME_MAX_LENGTH);
502 		*spot = '/';
503 	}
504 	if (strcmp(root_dir, tlm_acls->acl_root_dir) != 0) {
505 		struct stat64 attr;
506 
507 		erc = lstat64(root_dir, &attr);
508 		if (erc != 0) {
509 			NDMP_LOG(LOG_ERR, "Cannot find root directory %s.",
510 			    root_dir);
511 			free(checkpointed_dir);
512 			return (-1);
513 		}
514 		(void) strlcpy(tlm_acls->acl_root_dir, root_dir,
515 		    TLM_VOLNAME_MAX_LENGTH);
516 	}
517 	erc = acl_get(fil, ACL_NO_TRIVIAL, &aclp);
518 	if (erc != 0) {
519 		NDMP_LOG(LOG_DEBUG,
520 		    "Could not read metadata for directory [%s]", dir);
521 		free(checkpointed_dir);
522 		return (-1);
523 	}
524 	if (aclp && (acltp = acl_totext(aclp,
525 	    ACL_APPEND_ID | ACL_SID_FMT | ACL_COMPACT_FMT)) != NULL) {
526 		(void) strlcpy(tlm_acls->acl_info.attr_info, acltp,
527 		    TLM_MAX_ACL_TXT);
528 		acl_free(aclp);
529 		free(acltp);
530 	}
531 
532 	free(checkpointed_dir);
533 	return (0);
534 }
535 
536 /*
537  * backup_dir
538  *
539  * Create a TAR entry record for a directory
540  */
541 static int
542 backup_dir(char *dir, tlm_acls_t *tlm_acls,
543     tlm_cmd_t *local_commands, tlm_job_stats_t *job_stats,
544     bk_selector_t *bksp)
545 {
546 	int erc;
547 
548 	NDMP_LOG(LOG_DEBUG, "\"%s\"", dir);
549 
550 	erc = get_dir_acl_info(dir, tlm_acls, job_stats);
551 	if (erc != 0) {
552 		NDMP_LOG(LOG_DEBUG,
553 		    "Could not read directory info for %s", dir);
554 		job_stats->js_errors++;
555 	} else {
556 		/*
557 		 * See if the directory must be backed up.
558 		 */
559 		if (bksp && !(*bksp->bs_fn)(bksp, &tlm_acls->acl_attr)) {
560 			NDMP_LOG(LOG_DEBUG, "[%s] dir skipped", dir);
561 			return (erc);
562 		}
563 
564 		if (tm_tar_ops.tm_putdir != NULL)
565 			(void) (tm_tar_ops.tm_putdir)(dir, tlm_acls,
566 			    local_commands, job_stats);
567 	}
568 
569 	return (erc);
570 }
571 
572 
573 /*
574  * backup_file
575  *
576  * Create a TAR record entry for a file
577  */
578 static longlong_t
579 backup_file(char *dir, char *name, tlm_acls_t *tlm_acls,
580     tlm_commands_t *commands, tlm_cmd_t *local_commands,
581     tlm_job_stats_t *job_stats, bk_selector_t *bksp)
582 {
583 
584 	int erc;
585 	char buf[TLM_MAX_PATH_NAME];
586 	longlong_t rv;
587 
588 	NDMP_LOG(LOG_DEBUG, "\"%s/%s\"", dir, name);
589 
590 	(void) strlcpy(buf, dir, sizeof (buf));
591 	(void) strlcat(buf, "/", sizeof (buf));
592 	(void) strlcat(buf, name, sizeof (buf));
593 
594 	/*
595 	 * get_acl_info extracts file handle, attributes and ACLs of the file.
596 	 * This is not efficient when the attributes and file handle of
597 	 * the file is already known.
598 	 */
599 	erc = get_acl_info(buf, tlm_acls);
600 	if (erc != TLM_NO_ERRORS) {
601 		NDMP_LOG(LOG_ERR, "Could not open file %s/%s.", dir, name);
602 		return (-ENOENT);
603 	}
604 
605 	/* Should the file be backed up? */
606 	if (!bksp) {
607 		NDMP_LOG(LOG_DEBUG,
608 		    "[%s/%s] has no selection criteria", dir, name);
609 
610 	} else if (!((*bksp->bs_fn)(bksp, &tlm_acls->acl_attr))) {
611 		NDMP_LOG(LOG_DEBUG, "[%s/%s] file skipped", dir, name);
612 		return (0);
613 	}
614 
615 	/* Only the regular files and symbolic links can be backed up. */
616 	if (!S_ISLNK(tlm_acls->acl_attr.st_mode) &&
617 	    !S_ISREG(tlm_acls->acl_attr.st_mode)) {
618 		NDMP_LOG(LOG_DEBUG,
619 		    "Warning: skip backing up [%s][%s]", dir, name);
620 		return (-EINVAL);
621 	}
622 
623 
624 	if (tm_tar_ops.tm_putfile != NULL)
625 		rv = (tm_tar_ops.tm_putfile)(dir, name, tlm_acls, commands,
626 		    local_commands, job_stats);
627 
628 	return (rv);
629 }
630 
631 
632 
633 /*
634  * backup_work
635  *
636  * Start the NDMP backup (V2 only).
637  */
638 int
639 backup_work(char *bk_path, tlm_job_stats_t *job_stats,
640     ndmp_run_args_t *np, tlm_commands_t *commands,
641     ndmp_lbr_params_t *nlp)
642 {
643 	struct full_dir_info dir_info; /* the blob to push/pop with cstack_t */
644 	struct full_dir_info *t_dir_info, *p_dir_info;
645 	struct stat64 ret_attr; /* attributes of current file name */
646 	fs_fhandle_t ret_fh;
647 	char *first_name; /* where the first name is located */
648 	char *dname;
649 	int erc;
650 	int retval;
651 	cstack_t *stk;
652 	unsigned long fileid;
653 	tlm_acls_t tlm_acls;
654 	int dname_size;
655 	longlong_t fsize;
656 	bk_selector_t bks;
657 	tlm_cmd_t *local_commands;
658 	long 	dpos;
659 
660 	NDMP_LOG(LOG_DEBUG, "nr_chkpnted %d nr_ldate: %u bk_path: \"%s\"",
661 	    NLP_ISCHKPNTED(nlp), nlp->nlp_ldate, bk_path);
662 
663 	/* Get every name in this directory */
664 	dname = ndmp_malloc(TLM_MAX_PATH_NAME);
665 	if (dname == NULL)
666 		return (-ENOMEM);
667 
668 	local_commands = commands->tcs_command;
669 	retval = 0;
670 	(void) memset(&bks, 0, sizeof (bks));
671 	bks.bs_cookie = (void *)nlp;
672 	bks.bs_level = nlp->nlp_clevel;
673 	bks.bs_ldate = nlp->nlp_ldate;
674 	bks.bs_fn = timecmp;
675 
676 	/*
677 	 * should we skip the whole thing?
678 	 */
679 	if (tlm_is_excluded("", bk_path, np->nr_excls)) {
680 		NDMP_LOG(LOG_DEBUG, "%s excluded", bk_path);
681 		free(dname);
682 		return (0);
683 	}
684 
685 	/*
686 	 * Search for the top-level file-directory
687 	 */
688 	if (NLP_ISCHKPNTED(nlp)) {
689 		first_name = np->nr_chkp_nm;
690 		(void) strlcpy(first_name, bk_path, TLM_MAX_PATH_NAME);
691 	} else {
692 		first_name = tlm_build_snapshot_name(bk_path, np->nr_chkp_nm,
693 		    nlp->nlp_jstat->js_job_name);
694 	}
695 
696 	(void) memset(&ret_fh, 0, sizeof (ret_fh));
697 	erc = fs_getstat(first_name, &ret_fh, &ret_attr, NULL);
698 	if (erc != 0) {
699 		NDMP_LOG(LOG_ERR, "Path %s not found.", first_name);
700 		free(dname);
701 		return (-EINVAL);
702 	}
703 
704 	if ((stk = cstack_new()) == NULL) {
705 		free(dname);
706 		NDMP_LOG(LOG_DEBUG, "cstack_new failed");
707 		return (-ENOMEM);
708 	}
709 	(void) strlcpy(dir_info.fd_dir_name, first_name, TLM_MAX_PATH_NAME);
710 	(void) memcpy(&dir_info.fd_dir_fh, &ret_fh, sizeof (fs_fhandle_t));
711 	p_dir_info = dup_dir_info(&dir_info);
712 
713 	/*
714 	 * Push the first name onto the stack so that we can pop it back
715 	 * off as part of the normal cycle
716 	 */
717 	if (cstack_push(stk, p_dir_info, 0)) {
718 		free(dname);
719 		free(p_dir_info);
720 		cstack_delete(stk);
721 		NDMP_LOG(LOG_DEBUG, "cstack_push failed");
722 		return (-ENOMEM);
723 	}
724 
725 	(void) memset(&tlm_acls, 0, sizeof (tlm_acls));
726 	/*
727 	 * Did NDMP create a checkpoint?
728 	 */
729 	if (NLP_ISCHKPNTED(nlp) || fs_is_rdonly(bk_path)) {
730 		tlm_acls.acl_checkpointed = FALSE;
731 	} else {
732 		/* Use the checkpoint created by NDMP */
733 		tlm_acls.acl_checkpointed = TRUE;
734 	}
735 
736 	/*
737 	 * This is level-backup.  It never resets the archive bit.
738 	 */
739 	tlm_acls.acl_clear_archive = FALSE;
740 
741 	NDMP_LOG(LOG_DEBUG, "acls.chkpnt: %c acls.clear_arcbit: %c",
742 	    NDMP_YORN(tlm_acls.acl_checkpointed),
743 	    NDMP_YORN(tlm_acls.acl_clear_archive));
744 
745 	while (commands->tcs_reader == TLM_BACKUP_RUN &&
746 	    local_commands->tc_reader == TLM_BACKUP_RUN &&
747 	    cstack_pop(stk, (void **)&p_dir_info, 0) == 0) {
748 
749 		if (NLP_ISCHKPNTED(nlp))
750 			(void) strlcpy(np->nr_unchkp_nm,
751 			    p_dir_info->fd_dir_name, TLM_MAX_PATH_NAME);
752 		else
753 			(void) tlm_remove_checkpoint(p_dir_info->fd_dir_name,
754 			    np->nr_unchkp_nm);
755 
756 		(void) backup_dir(np->nr_unchkp_nm, &tlm_acls, local_commands,
757 		    job_stats, &bks);
758 
759 
760 		while (commands->tcs_reader == TLM_BACKUP_RUN &&
761 		    local_commands->tc_reader == TLM_BACKUP_RUN) {
762 
763 			dname_size = TLM_MAX_PATH_NAME - 1;
764 
765 			NDMP_LOG(LOG_DEBUG,
766 			    "dir_name: %s", p_dir_info->fd_dir_name);
767 
768 			(void) memset(&ret_fh, 0, sizeof (ret_fh));
769 			erc = fs_readdir(&p_dir_info->fd_dir_fh,
770 			    p_dir_info->fd_dir_name, &dpos,
771 			    dname, &dname_size, &ret_fh, &ret_attr,
772 			    NULL);
773 			if (erc == 0) {
774 				fileid = ret_fh.fh_fid;
775 			} else {
776 				NDMP_LOG(LOG_DEBUG,
777 				    "Filesystem readdir in [%s]",
778 				    p_dir_info->fd_dir_name);
779 				retval = -ENOENT;
780 				break;
781 			}
782 
783 			/* an empty name size marks the end of the list */
784 			if (dname_size == 0)
785 				break;
786 			dname[dname_size] = '\0';
787 
788 			NDMP_LOG(LOG_DEBUG, "dname: \"%s\"", dname);
789 
790 			/*
791 			 * If name refers to a directory, push its file
792 			 *   handle onto the stack  (skip "." and "..").
793 			 */
794 			if (rootfs_dot_or_dotdot(dname)) {
795 				fileid = 0;
796 				continue;
797 			}
798 
799 			/*
800 			 * Skip the:
801 			 * non-dir entries which should not be backed up
802 			 * Or
803 			 * dir-type entries which have have nothing under
804 			 * their hierarchy to be backed up.
805 			 */
806 			if (!dbm_getone(nlp->nlp_bkmap, (u_longlong_t)fileid)) {
807 				NDMP_LOG(LOG_DEBUG, "Skipping %s/%s",
808 				    p_dir_info->fd_dir_name, dname);
809 				fileid = 0;
810 				continue;
811 			}
812 
813 			if (tlm_is_excluded(np->nr_unchkp_nm, dname,
814 			    np->nr_excls)) {
815 				fileid = 0;
816 				continue;
817 			}
818 			if (S_ISDIR(ret_attr.st_mode)) {
819 				/*
820 				 * only directories get pushed onto this stack,
821 				 * so we do not have to test for regular files.
822 				 */
823 				t_dir_info = tlm_new_dir_info(&ret_fh,
824 				    p_dir_info->fd_dir_name, dname);
825 				if (t_dir_info == NULL) {
826 					NDMP_LOG(LOG_DEBUG,
827 					    "While backing up [%s][%s]",
828 					    p_dir_info->fd_dir_name, dname);
829 				} else if (cstack_push(stk, t_dir_info,
830 				    0) != 0) {
831 					NDMP_LOG(LOG_DEBUG,
832 					    "No enough memory stack_push");
833 					retval = -ENOMEM;
834 					break;
835 				}
836 			} else if (S_ISREG(ret_attr.st_mode) ||
837 			    S_ISLNK(ret_attr.st_mode)) {
838 
839 				fsize = backup_file(np->nr_unchkp_nm, dname,
840 				    &tlm_acls, commands, local_commands,
841 				    job_stats, &bks);
842 
843 				if (fsize >= 0) {
844 					job_stats->js_files_so_far++;
845 					job_stats->js_bytes_total += fsize;
846 				} else
847 					job_stats->js_errors++;
848 				fileid = 0;
849 			}
850 		}
851 		fileid = 0;
852 		free(p_dir_info);
853 		if (retval != 0)
854 			break;
855 	}
856 
857 	free(dname);
858 
859 	while (cstack_pop(stk, (void **)&p_dir_info, 0) == 0) {
860 		free(p_dir_info);
861 	}
862 
863 	cstack_delete(stk);
864 	return (retval);
865 }
866 
867 
868 /*
869  * free_paths
870  *
871  * Free the path names
872  */
873 static void
874 free_paths(ndmp_run_args_t *np)
875 {
876 	free(np->nr_chkp_nm);
877 	free(np->nr_unchkp_nm);
878 	free(np->nr_excls);
879 }
880 
881 
882 /*
883  * malloc_paths
884  *
885  * Allocate the path names (direct and checkpointed paths)
886  */
887 static boolean_t
888 malloc_paths(ndmp_run_args_t *np)
889 {
890 	boolean_t rv;
891 
892 	rv = TRUE;
893 	np->nr_chkp_nm = ndmp_malloc(TLM_MAX_PATH_NAME);
894 	np->nr_unchkp_nm = ndmp_malloc(TLM_MAX_PATH_NAME);
895 	if (!np->nr_chkp_nm || !np->nr_unchkp_nm) {
896 		free_paths(np);
897 		rv = FALSE;
898 	} else if ((np->nr_excls = ndmpd_make_exc_list()) == NULL) {
899 		free_paths(np);
900 		rv = FALSE;
901 	}
902 	return (rv);
903 }
904 
905 
906 /*
907  * ndmp_backup_reader
908  *
909  * Backup reader thread which uses backup_work to read and TAR
910  * the files/dirs to be backed up (V2 only)
911  */
912 static int
913 ndmp_backup_reader(tlm_commands_t *commands, ndmp_lbr_params_t *nlp,
914     char *job_name)
915 {
916 	int retval;
917 	ndmp_run_args_t np;
918 	tlm_job_stats_t *job_stats;
919 	tlm_cmd_t *local_commands;
920 
921 	NDMP_LOG(LOG_DEBUG, "bk_path: \"%s\"", nlp->nlp_backup_path);
922 
923 	local_commands = commands->tcs_command;
924 	(void) memset(&np, 0, sizeof (np));
925 	if (!malloc_paths(&np))
926 		return (-1);
927 	local_commands->tc_ref++;
928 	commands->tcs_reader_count++;
929 
930 	job_stats = tlm_ref_job_stats(job_name);
931 
932 	retval = backup_work(nlp->nlp_backup_path, job_stats, &np,
933 	    commands, nlp);
934 	write_tar_eof(local_commands);
935 
936 	commands->tcs_reader_count--;
937 	local_commands->tc_writer = TLM_STOP;
938 	tlm_release_reader_writer_ipc(local_commands);
939 	tlm_un_ref_job_stats(job_name);
940 
941 	free_paths(&np);
942 	return (retval);
943 
944 }
945 
946 
947 /*
948  * ndmp_tar_writer
949  *
950  * The backup writer thread that writes the TAR records to the
951  * tape media (V2 only)
952  */
953 int
954 ndmp_tar_writer(ndmpd_session_t *session, ndmpd_module_params_t *mod_params,
955     tlm_commands_t *cmds)
956 {
957 	int bidx, nw;
958 	int err;
959 	tlm_buffer_t *buf;
960 	tlm_buffers_t *bufs;
961 	tlm_cmd_t *lcmd;	/* Local command */
962 
963 	err = 0;
964 	if (session == NULL) {
965 		NDMP_LOG(LOG_DEBUG, "session == NULL");
966 		err = -1;
967 	} else if (mod_params == NULL) {
968 		NDMP_LOG(LOG_DEBUG, "mod_params == NULL");
969 		err = -1;
970 	} else if (cmds == NULL) {
971 		NDMP_LOG(LOG_DEBUG, "cmds == NULL");
972 		err = -1;
973 	}
974 
975 	if (err != 0)
976 		return (err);
977 
978 	lcmd = cmds->tcs_command;
979 	bufs = lcmd->tc_buffers;
980 
981 	lcmd->tc_ref++;
982 	cmds->tcs_writer_count++;
983 
984 	nw = 0;
985 	buf = tlm_buffer_out_buf(bufs, &bidx);
986 	while (cmds->tcs_writer != (int)TLM_ABORT &&
987 	    lcmd->tc_writer != (int)TLM_ABORT) {
988 		if (buf->tb_full) {
989 			NDMP_LOG(LOG_DEBUG, "w%d", bidx);
990 
991 			if (MOD_WRITE(mod_params, buf->tb_buffer_data,
992 			    buf->tb_buffer_size) != 0) {
993 				NDMP_LOG(LOG_DEBUG,
994 				    "Writing buffer %d, pos: %lld",
995 				    bidx, session->ns_mover.md_position);
996 				err = -1;
997 				break;
998 			}
999 
1000 			tlm_buffer_mark_empty(buf);
1001 			(void) tlm_buffer_advance_out_idx(bufs);
1002 			buf = tlm_buffer_out_buf(bufs, &bidx);
1003 			tlm_buffer_release_out_buf(bufs);
1004 			nw++;
1005 		} else {
1006 			if (lcmd->tc_writer != TLM_BACKUP_RUN) {
1007 				/* No more data is comming; time to exit. */
1008 				NDMP_LOG(LOG_DEBUG,
1009 				    "tc_writer!=TLM_BACKUP_RUN; time to exit");
1010 				break;
1011 			} else {
1012 				NDMP_LOG(LOG_DEBUG, "W%d", bidx);
1013 				tlm_buffer_in_buf_wait(bufs);
1014 			}
1015 		}
1016 	}
1017 
1018 	NDMP_LOG(LOG_DEBUG, "nw: %d", nw);
1019 	if (cmds->tcs_writer != (int)TLM_ABORT) {
1020 		NDMP_LOG(LOG_DEBUG, "tcs_writer != TLM_ABORT");
1021 	} else {
1022 		NDMP_LOG(LOG_DEBUG, "tcs_writer == TLM_ABORT");
1023 	}
1024 
1025 	if (lcmd->tc_writer != (int)TLM_ABORT) {
1026 		NDMP_LOG(LOG_DEBUG, "tc_writer != TLM_ABORT");
1027 	} else {
1028 		NDMP_LOG(LOG_DEBUG, "tc_writer == TLM_ABORT");
1029 	}
1030 	cmds->tcs_writer_count--;
1031 	lcmd->tc_reader = TLM_STOP;
1032 	lcmd->tc_ref--;
1033 
1034 	return (err);
1035 }
1036 
1037 
1038 /*
1039  * read_one_buf
1040  *
1041  * Read one buffer from the tape
1042  */
1043 static int
1044 read_one_buf(ndmpd_module_params_t *mod_params, tlm_buffers_t *bufs,
1045     tlm_buffer_t *buf)
1046 {
1047 	int rv;
1048 
1049 	if ((rv = MOD_READ(mod_params, buf->tb_buffer_data,
1050 	    bufs->tbs_data_transfer_size)) == 0) {
1051 		buf->tb_eof = buf->tb_eot = FALSE;
1052 		buf->tb_errno = 0;
1053 		buf->tb_buffer_size = bufs->tbs_data_transfer_size;
1054 		buf->tb_buffer_spot = 0;
1055 		buf->tb_full = TRUE;
1056 		(void) tlm_buffer_advance_in_idx(bufs);
1057 	}
1058 
1059 	return (rv);
1060 }
1061 
1062 
1063 /*
1064  * ndmp_tar_reader
1065  *
1066  * NDMP Tar reader thread. This threads keep reading the tar
1067  * file from the tape and wakes up the consumer thread to extract
1068  * it on the disk
1069  */
1070 int
1071 ndmp_tar_reader(ndmp_tar_reader_arg_t *argp)
1072 {
1073 	int bidx;
1074 	int err;
1075 	tlm_buffer_t *buf;
1076 	tlm_buffers_t *bufs;
1077 	tlm_cmd_t *lcmd;	/* Local command */
1078 	ndmpd_session_t *session;
1079 	ndmpd_module_params_t *mod_params;
1080 	tlm_commands_t *cmds;
1081 
1082 	if (!argp)
1083 		return (-1);
1084 
1085 	session = argp->tr_session;
1086 	mod_params = argp->tr_mod_params;
1087 	cmds = argp->tr_cmds;
1088 
1089 	err = 0;
1090 	if (session == NULL) {
1091 		NDMP_LOG(LOG_DEBUG, "session == NULL");
1092 		err = -1;
1093 	} else if (cmds == NULL) {
1094 		NDMP_LOG(LOG_DEBUG, "cmds == NULL");
1095 		err = -1;
1096 	}
1097 
1098 	if (err != 0) {
1099 		tlm_cmd_signal(cmds->tcs_command, TLM_TAR_READER);
1100 		return (err);
1101 	}
1102 
1103 	lcmd = cmds->tcs_command;
1104 	bufs = lcmd->tc_buffers;
1105 
1106 	lcmd->tc_ref++;
1107 	cmds->tcs_reader_count++;
1108 
1109 	/*
1110 	 * Synchronize with our parent thread.
1111 	 */
1112 	tlm_cmd_signal(cmds->tcs_command, TLM_TAR_READER);
1113 
1114 	buf = tlm_buffer_in_buf(bufs, &bidx);
1115 	while (cmds->tcs_reader == TLM_RESTORE_RUN &&
1116 	    lcmd->tc_reader == TLM_RESTORE_RUN) {
1117 
1118 		if (buf->tb_full) {
1119 			NDMP_LOG(LOG_DEBUG, "R%d", bidx);
1120 			/*
1121 			 * The buffer is still full, wait for the consumer
1122 			 * thread to use it.
1123 			 */
1124 			tlm_buffer_out_buf_timed_wait(bufs, 100);
1125 			buf = tlm_buffer_in_buf(bufs, NULL);
1126 		} else {
1127 			NDMP_LOG(LOG_DEBUG, "r%d", bidx);
1128 
1129 			err = read_one_buf(mod_params, bufs, buf);
1130 			if (err < 0) {
1131 				NDMP_LOG(LOG_DEBUG,
1132 				    "Reading buffer %d, pos: %lld",
1133 				    bidx, session->ns_mover.md_position);
1134 
1135 				/* Force the writer to stop. */
1136 				buf->tb_eot = buf->tb_eof = TRUE;
1137 				break;
1138 			} else if (err == 1) {
1139 				NDMP_LOG(LOG_DEBUG,
1140 				    "operation aborted or session terminated");
1141 				err = 0;
1142 				break;
1143 			}
1144 
1145 			buf = tlm_buffer_in_buf(bufs, &bidx);
1146 			tlm_buffer_release_in_buf(bufs);
1147 		}
1148 	}
1149 
1150 	/*
1151 	 * If the consumer is waiting for us, wake it up so that it detects
1152 	 * we're quiting.
1153 	 */
1154 	lcmd->tc_writer = TLM_STOP;
1155 	tlm_buffer_release_in_buf(bufs);
1156 	(void) usleep(1000);
1157 
1158 	/*
1159 	 * Clean up.
1160 	 */
1161 	cmds->tcs_reader_count--;
1162 	lcmd->tc_ref--;
1163 	return (err);
1164 }
1165 
1166 
1167 /*
1168  * ndmpd_tar_backup
1169  *
1170  * Check must have been done that backup work directory exists, before
1171  * calling this function.
1172  */
1173 static int
1174 ndmpd_tar_backup(ndmpd_session_t *session, ndmpd_module_params_t *mod_params,
1175     ndmp_lbr_params_t *nlp)
1176 {
1177 	char jname[TLM_MAX_BACKUP_JOB_NAME];
1178 	int err;
1179 	tlm_commands_t *cmds;
1180 
1181 	if (mod_params->mp_operation != NDMP_DATA_OP_BACKUP) {
1182 		NDMP_LOG(LOG_DEBUG,
1183 		    "mod_params->mp_operation != NDMP_DATA_OP_BACKUP");
1184 		err = -1;
1185 	} else {
1186 		if (ndmpd_mark_inodes_v2(session, nlp) != 0)
1187 			err = -1;
1188 		else if (ndmp_get_bk_dir_ino(nlp))
1189 			err = -1;
1190 		else
1191 			err = 0;
1192 	}
1193 
1194 	if (err != 0)
1195 		return (err);
1196 
1197 	(void) ndmp_new_job_name(jname);
1198 	if (backup_create_structs(session, jname) < 0)
1199 		return (-1);
1200 
1201 	nlp->nlp_jstat->js_start_ltime = time(NULL);
1202 	nlp->nlp_jstat->js_start_time = nlp->nlp_jstat->js_start_ltime;
1203 	nlp->nlp_jstat->js_chkpnt_time = nlp->nlp_cdate;
1204 
1205 	if (!session->ns_data.dd_abort) {
1206 
1207 		cmds = &nlp->nlp_cmds;
1208 		cmds->tcs_reader = cmds->tcs_writer = TLM_BACKUP_RUN;
1209 		cmds->tcs_command->tc_reader = TLM_BACKUP_RUN;
1210 		cmds->tcs_command->tc_writer = TLM_BACKUP_RUN;
1211 
1212 		if (ndmp_write_utf8magic(cmds->tcs_command) < 0) {
1213 			backup_release_structs(session);
1214 			return (-1);
1215 		}
1216 
1217 		NDMP_LOG(LOG_DEBUG, "Backing up \"%s\" started.",
1218 		    nlp->nlp_backup_path);
1219 
1220 		err = ndmp_backup_reader(cmds, nlp, jname);
1221 		if (err != 0) {
1222 			backup_release_structs(session);
1223 			NDMP_LOG(LOG_DEBUG, "Launch ndmp_backup_reader: %s",
1224 			    strerror(err));
1225 			return (-1);
1226 		}
1227 
1228 		/* Act as the writer thread. */
1229 		err = ndmp_tar_writer(session, mod_params, cmds);
1230 
1231 		nlp->nlp_jstat->js_stop_time = time(NULL);
1232 
1233 		NDMP_LOG(LOG_DEBUG,
1234 		    "Runtime [%s] %llu bytes (%llu): %d seconds",
1235 		    nlp->nlp_backup_path, session->ns_mover.md_data_written,
1236 		    session->ns_mover.md_data_written,
1237 		    nlp->nlp_jstat->js_stop_time -
1238 		    nlp->nlp_jstat->js_start_ltime);
1239 		MOD_LOG(mod_params,
1240 		    "Runtime [%s] %llu bytes (%llu): %d seconds",
1241 		    nlp->nlp_backup_path, session->ns_mover.md_data_written,
1242 		    session->ns_mover.md_data_written,
1243 		    nlp->nlp_jstat->js_stop_time -
1244 		    nlp->nlp_jstat->js_start_ltime);
1245 
1246 		if (session->ns_data.dd_abort)
1247 			err = -1;
1248 
1249 		NDMP_LOG(LOG_DEBUG, "Backing up \"%s\" finished. (%d)",
1250 		    nlp->nlp_backup_path, err);
1251 	} else {
1252 		nlp->nlp_jstat->js_stop_time = time(NULL);
1253 		NDMP_LOG(LOG_DEBUG, "Backing up \"%s\" aborted.",
1254 		    nlp->nlp_backup_path);
1255 		err = 0;
1256 	}
1257 
1258 	backup_release_structs(session);
1259 	return (err);
1260 }
1261 
1262 
1263 /*
1264  * ndmpd_tar_restore
1265  *
1266  * Restore function that launches TAR reader thread to read from the
1267  * tape and writes the extracted files/dirs to the filesystem
1268  */
1269 static int
1270 ndmpd_tar_restore(ndmpd_session_t *session, ndmpd_module_params_t *mod_params,
1271     ndmp_lbr_params_t *nlp)
1272 {
1273 	char jname[TLM_MAX_BACKUP_JOB_NAME];
1274 	char *rspath;
1275 	int err;
1276 	tlm_commands_t *cmds;
1277 	ndmp_tar_reader_arg_t arg;
1278 	tlm_backup_restore_arg_t tlm_arg;
1279 	ndmp_name *ent;
1280 	pthread_t rdtp, wrtp;
1281 	int i;
1282 
1283 	if (mod_params->mp_operation != NDMP_DATA_OP_RECOVER) {
1284 		NDMP_LOG(LOG_DEBUG,
1285 		    "mod_params->mp_operation != NDMP_DATA_OP_RECOVER");
1286 		return (-1);
1287 	}
1288 
1289 	if (nlp->nlp_restore_path[0] != '\0')
1290 		rspath = nlp->nlp_restore_path;
1291 	else if (nlp->nlp_restore_bk_path[0] != '\0')
1292 		rspath = nlp->nlp_restore_bk_path;
1293 	else
1294 		rspath = "";
1295 
1296 	(void) ndmp_new_job_name(jname);
1297 	if (restore_create_structs(session, jname) < 0)
1298 		return (-1);
1299 
1300 	nlp->nlp_jstat->js_start_ltime = time(NULL);
1301 	nlp->nlp_jstat->js_start_time = time(NULL);
1302 
1303 	if (!session->ns_data.dd_abort) {
1304 		cmds = &nlp->nlp_cmds;
1305 		cmds->tcs_reader = cmds->tcs_writer = TLM_RESTORE_RUN;
1306 		cmds->tcs_command->tc_reader = TLM_RESTORE_RUN;
1307 		cmds->tcs_command->tc_writer = TLM_RESTORE_RUN;
1308 
1309 		NDMP_LOG(LOG_DEBUG, "Restoring to \"%s\" started.", rspath);
1310 		NDMP_LOG(LOG_DEBUG, "Restoring from %s tape(s).",
1311 		    ndmp_data_get_mover_mode(session));
1312 
1313 		arg.tr_session = session;
1314 		arg.tr_mod_params = mod_params;
1315 		arg.tr_cmds = cmds;
1316 
1317 		err = pthread_create(&rdtp, NULL, (funct_t)ndmp_tar_reader,
1318 		    (void *)&arg);
1319 		if (err == 0) {
1320 			tlm_cmd_wait(cmds->tcs_command, TLM_TAR_READER);
1321 		} else {
1322 			NDMP_LOG(LOG_DEBUG, "Launch ndmp_tar_reader: %m");
1323 			return (-1);
1324 		}
1325 
1326 		if (!ndmp_check_utf8magic(cmds->tcs_command)) {
1327 			NDMP_LOG(LOG_DEBUG, "UTF8Magic not found!");
1328 		} else {
1329 			NDMP_LOG(LOG_DEBUG, "UTF8Magic found");
1330 		}
1331 
1332 		(void) memset(&tlm_arg, 0, sizeof (tlm_backup_restore_arg_t));
1333 		(void) pthread_barrier_init(&tlm_arg.ba_barrier, 0, 2);
1334 
1335 		/*
1336 		 * Set up restore parameters
1337 		 */
1338 		tlm_arg.ba_commands = cmds;
1339 		tlm_arg.ba_cmd = cmds->tcs_command;
1340 		tlm_arg.ba_job = nlp->nlp_jstat->js_job_name;
1341 		tlm_arg.ba_dir = nlp->nlp_restore_path;
1342 		for (i = 0; i < nlp->nlp_nfiles; i++) {
1343 			ent = (ndmp_name *)MOD_GETNAME(mod_params, i);
1344 			tlm_arg.ba_sels[i] = ent->name;
1345 		}
1346 
1347 
1348 		if (tm_tar_ops.tm_getfile != NULL) {
1349 			err = pthread_create(&wrtp, NULL,
1350 			    (funct_t)tm_tar_ops.tm_getfile, (void *)&tlm_arg);
1351 		} else {
1352 			(void) pthread_barrier_destroy(&tlm_arg.ba_barrier);
1353 			NDMP_LOG(LOG_DEBUG,
1354 			    "Thread create tm_getfile: ops NULL");
1355 			return (-1);
1356 		}
1357 		if (err == 0) {
1358 			(void) pthread_barrier_wait(&tlm_arg.ba_barrier);
1359 		} else {
1360 			(void) pthread_barrier_destroy(&tlm_arg.ba_barrier);
1361 			NDMP_LOG(LOG_DEBUG, "thread create tm_getfile: %m");
1362 			return (-1);
1363 		}
1364 
1365 		(void) pthread_join(rdtp, NULL);
1366 		(void) pthread_join(wrtp, NULL);
1367 		(void) pthread_barrier_destroy(&tlm_arg.ba_barrier);
1368 
1369 		nlp->nlp_jstat->js_stop_time = time(NULL);
1370 
1371 		/* Send the list of un-recovered files/dirs to the client.  */
1372 		(void) send_unrecovered_list(mod_params, nlp);
1373 
1374 		ndmp_stop_local_reader(session, cmds);
1375 		ndmp_wait_for_reader(cmds);
1376 		ndmp_stop_remote_reader(session);
1377 		NDMP_LOG(LOG_DEBUG, "Restoring to \"%s\" finished. (%d)",
1378 		    rspath, err);
1379 	} else {
1380 		nlp->nlp_jstat->js_stop_time = time(NULL);
1381 
1382 		/* nothing restored. */
1383 		(void) send_unrecovered_list(mod_params, nlp);
1384 		NDMP_LOG(LOG_DEBUG, "Restoring to \"%s\" aborted.",
1385 		    rspath);
1386 		err = -1;
1387 	}
1388 
1389 	NDMP_FREE(nlp->nlp_restore_path);
1390 	backup_release_structs(session);
1391 
1392 	return (err);
1393 }
1394 
1395 
1396 /*
1397  * prefixdir
1398  *
1399  * Extract the path for a given full path entry
1400  */
1401 static char *
1402 prefixdir(char *dir, char *suffix)
1403 {
1404 	static char tmp[TLM_MAX_PATH_NAME];
1405 	char *tend, *send; /* tmp and suffix end */
1406 
1407 	if (dir == NULL || suffix == NULL)
1408 		return (NULL);
1409 
1410 	if (*suffix == '\0')
1411 		return (dir);
1412 
1413 	if (*dir == '\0')
1414 		return (NULL);
1415 
1416 	(void) strlcpy(tmp, dir, TLM_MAX_PATH_NAME);
1417 	tend = &tmp[strlen(tmp)];
1418 	send = &suffix[strlen(suffix)];
1419 
1420 	/*
1421 	 * Move backward as far as the last part of the dir and
1422 	 * the suffix match.
1423 	 */
1424 	while (tend >= tmp && send >= suffix)
1425 		if (*tend == *send)
1426 			tend--, send--;
1427 		else
1428 			break;
1429 
1430 	*++tend = '\0';
1431 	return (tmp);
1432 }
1433 
1434 
1435 /*
1436  * get_backup_path
1437  *
1438  * Find the backup path from the environment variables
1439  */
1440 static char *
1441 get_backup_path(ndmpd_module_params_t *params)
1442 {
1443 	char *bkpath;
1444 
1445 	bkpath = MOD_GETENV(params, "PREFIX");
1446 	if (bkpath == NULL)
1447 		bkpath = MOD_GETENV(params, "FILESYSTEM");
1448 
1449 	if (bkpath == NULL) {
1450 		MOD_LOG(params, "Error: restore path not specified.\n");
1451 		return (NULL);
1452 	}
1453 
1454 	if (*bkpath != '/') {
1455 		MOD_LOG(params, "Error: relative backup path not allowed.\n");
1456 		return (NULL);
1457 	}
1458 
1459 	return (bkpath);
1460 }
1461 
1462 
1463 /*
1464  * get_nfiles
1465  *
1466  * Get the count of files to be restored
1467  */
1468 static int
1469 get_nfiles(ndmpd_session_t *session, ndmpd_module_params_t *params)
1470 {
1471 	if (session->ns_data.dd_nlist_len == 0) {
1472 		MOD_LOG(params, "Error: nothing specified to be restored.\n");
1473 		return (-1);
1474 	}
1475 
1476 	return (session->ns_data.dd_nlist_len);
1477 }
1478 
1479 
1480 /*
1481  * get_restore_dest
1482  *
1483  * Get the full pathname of where the entries should be restored to.
1484  */
1485 static char *
1486 get_restore_dest(ndmpd_module_params_t *params)
1487 {
1488 	ndmp_name *ent;
1489 	char *cp;
1490 
1491 	/*
1492 	 * Destination of restore:
1493 	 * NetBackup of Veritas(C) sends the entries like this:
1494 	 *
1495 	 *	ent[i].name: is the relative pathname of what is selected in
1496 	 *	  the GUI.
1497 	 *	ent[i].dest: is the full pathname of where the dir/file must
1498 	 *	  be restored to.
1499 	 *	ent[i].ssi: 0
1500 	 *	ent[i].fh_info: 0
1501 	 *
1502 	 */
1503 	ent = (ndmp_name *)MOD_GETNAME(params, 0);
1504 	cp = prefixdir(ent->dest, ent->name);
1505 	if (cp == NULL) {
1506 		MOD_LOG(params, "Error: empty restore path.\n");
1507 		return (NULL);
1508 	}
1509 
1510 	return (cp);
1511 }
1512 
1513 
1514 /*
1515  * correct_ents
1516  *
1517  * Correct the entries in the restore list by appending the appropriate
1518  * path to them
1519  */
1520 static int
1521 correct_ents(ndmpd_module_params_t *params, int n, char *bkpath)
1522 {
1523 	char *cp, *pathname;
1524 	int i, len, rv;
1525 	ndmp_name *ent;
1526 
1527 	if ((pathname = ndmp_malloc(TLM_MAX_PATH_NAME)) == NULL) {
1528 		MOD_LOG(params, "Error: insufficient memory.\n");
1529 		return (-1);
1530 	}
1531 
1532 	rv = 0;
1533 	/* Append the backup path to all the "ent[].name"s. */
1534 	for (i = 0; i < n; i++) {
1535 		ent = (ndmp_name *)MOD_GETNAME(params, i);
1536 
1537 		NDMP_LOG(LOG_DEBUG,
1538 		    "Old: ent[%d].name: \"%s\"", i, ent->name);
1539 		NDMP_LOG(LOG_DEBUG,
1540 		    "Old: ent[%d].dest: \"%s\"", i, ent->dest);
1541 
1542 		/* remove trailing slash */
1543 		len = strlen(ent->name);
1544 		if (ent->name[len - 1] == '/')
1545 			ent->name[len - 1] = '\0';
1546 
1547 		if (!tlm_cat_path(pathname, bkpath, ent->name)) {
1548 			MOD_LOG(params, "Error: path too long.\n");
1549 			rv = -1;
1550 			break;
1551 		}
1552 
1553 		/* Make a copy of the new string and save it in ent->name. */
1554 		cp = strdup(pathname);
1555 		if (cp == NULL) {
1556 			MOD_LOG(params, "Error: insufficient memory.\n");
1557 			rv = -1;
1558 			break;
1559 		}
1560 		free(ent->name);
1561 		ent->name = cp;
1562 
1563 		NDMP_LOG(LOG_DEBUG,
1564 		    "New: ent[%d].name: \"%s\"", i, ent->name);
1565 	}
1566 
1567 	free(pathname);
1568 	return (rv);
1569 }
1570 
1571 
1572 /*
1573  * check_restore_paths
1574  *
1575  * Go through the restore list and check the validity of the
1576  * restore path.
1577  */
1578 static int
1579 check_restore_paths(ndmpd_module_params_t *params, int n, char *rspath)
1580 {
1581 	int i, rv;
1582 	ndmp_name *ent;
1583 
1584 	rv = 0;
1585 	if (rspath != NULL && *rspath != '\0') {
1586 		NDMP_LOG(LOG_DEBUG, "rspath: \"%s\"", rspath);
1587 		if (!fs_volexist(rspath)) {
1588 			MOD_LOG(params,
1589 			    "Error: Invalid volume name for restore.");
1590 			rv = -1;
1591 		}
1592 	} else {
1593 		for (i = 0; i < n; i++) {
1594 			ent = (ndmp_name *)MOD_GETNAME(params, i);
1595 			NDMP_LOG(LOG_DEBUG,
1596 			    "ent[%d].name: \"%s\"", i, ent->name);
1597 
1598 			if (!fs_volexist(ent->name)) {
1599 				MOD_LOG(params,
1600 				    "Error: Invalid volume name for restore.",
1601 				    ent->name);
1602 				rv = -1;
1603 				break;
1604 			}
1605 		}
1606 	}
1607 
1608 	return (rv);
1609 }
1610 
1611 
1612 /*
1613  * check_backup_dir_validity
1614  *
1615  * Check if the backup directory is valid. Make sure it exists and
1616  * is writable. Check for snapshot and readonly cases.
1617  */
1618 static int
1619 check_backup_dir_validity(ndmpd_module_params_t *params, char *bkpath)
1620 {
1621 	char *msg;
1622 	int rv;
1623 	struct stat64 st;
1624 
1625 	rv = NDMP_NO_ERR;
1626 	if (stat64(bkpath, &st) < 0) {
1627 		msg = strerror(errno);
1628 		MOD_LOG(params, "Error: stat(%s): %s.\n", bkpath, msg);
1629 		rv = NDMP_ILLEGAL_ARGS_ERR;
1630 	} else if (!S_ISDIR(st.st_mode)) {
1631 		MOD_LOG(params, "Error: %s is not a directory.\n", bkpath);
1632 		rv = NDMP_ILLEGAL_ARGS_ERR;
1633 	} else if (ndmp_is_chkpnt_root(bkpath)) {
1634 		/* It's a .chkpnt directory */
1635 		MOD_LOG(params, "Error: %s is a checkpoint root directory.\n",
1636 		    bkpath);
1637 		rv = NDMP_BAD_FILE_ERR;
1638 	} else if (fs_is_rdonly(bkpath) && !fs_is_chkpntvol(bkpath) &&
1639 	    fs_is_chkpnt_enabled(bkpath)) {
1640 		MOD_LOG(params, "Error: %s is not a checkpointed path.\n",
1641 		    bkpath);
1642 		rv = NDMP_BAD_FILE_ERR;
1643 	}
1644 
1645 	return (rv);
1646 }
1647 
1648 
1649 /*
1650  * ndmp_backup_extract_params
1651  *
1652  * Go through the backup parameters and check the validity
1653  * for each one. Then set the NLP flags according to the parameters.
1654  */
1655 int
1656 ndmp_backup_extract_params(ndmpd_session_t *session,
1657     ndmpd_module_params_t *params)
1658 {
1659 	char *cp;
1660 	int rv;
1661 	ndmp_lbr_params_t *nlp;
1662 
1663 	/* Extract directory to be backed up from env variables */
1664 	if ((nlp = ndmp_get_nlp(session)) == NULL) {
1665 		MOD_LOG(params, "Error: Internal error: nlp == NULL.\n");
1666 		return (NDMP_ILLEGAL_ARGS_ERR);
1667 	}
1668 	if ((nlp->nlp_backup_path = get_backup_path(params)) == NULL)
1669 		return (NDMP_FILE_NOT_FOUND_ERR);
1670 
1671 	if ((rv = check_backup_dir_validity(params,
1672 	    nlp->nlp_backup_path)) != NDMP_NO_ERR)
1673 		return (rv);
1674 
1675 	/* Should the st_ctime be ignored when backing up? */
1676 	if (ndmp_ignore_ctime) {
1677 		NDMP_LOG(LOG_DEBUG, "ignoring st_ctime");
1678 		NLP_SET(nlp, NLPF_IGNCTIME);
1679 	} else
1680 		NLP_UNSET(nlp, NLPF_IGNCTIME);
1681 
1682 	/* Should the st_lmtime be ignored when backing up? */
1683 	if (ndmp_include_lmtime) {
1684 		NDMP_LOG(LOG_DEBUG, "including st_lmtime");
1685 		NLP_SET(nlp, NLPF_INCLMTIME);
1686 	} else
1687 		NLP_UNSET(nlp, NLPF_INCLMTIME);
1688 
1689 	NDMP_LOG(LOG_DEBUG, "flags %x", nlp->nlp_flags);
1690 
1691 	/* Is backup history requested? */
1692 	cp = MOD_GETENV(params, "HIST");
1693 	if (cp == NULL) {
1694 		NDMP_LOG(LOG_DEBUG, "env(HIST) not specified");
1695 		NLP_UNSET(nlp, NLPF_FH);
1696 	} else {
1697 		NDMP_LOG(LOG_DEBUG, "env(HIST): \"%s\"", cp);
1698 
1699 		if (strchr("t_ty_y", *cp))
1700 			NLP_SET(nlp, NLPF_FH);
1701 		else
1702 			NLP_UNSET(nlp, NLPF_FH);
1703 	}
1704 
1705 	nlp->nlp_clevel = 0;
1706 	/* Is it an incremental backup? */
1707 	cp = MOD_GETENV(params, "LEVEL");
1708 	if (cp == NULL) {
1709 		NDMP_LOG(LOG_DEBUG,
1710 		    "env(LEVEL) not specified, default to 0");
1711 	} else if (*cp < '0' || *cp > '9' || *(cp+1) != '\0') {
1712 		NDMP_LOG(LOG_DEBUG, "Invalid backup level '%s'", cp);
1713 		return (NDMP_ILLEGAL_ARGS_ERR);
1714 	} else
1715 		nlp->nlp_clevel = *cp - '0';
1716 
1717 	/* Extract last backup time from the dumpdates file */
1718 	nlp->nlp_llevel = nlp->nlp_clevel;
1719 	nlp->nlp_ldate = 0;
1720 	if (ndmpd_get_dumptime(nlp->nlp_backup_path, &nlp->nlp_llevel,
1721 	    &nlp->nlp_ldate) < 0) {
1722 		MOD_LOG(params, "Error: getting dumpdate for %s level %d\n",
1723 		    nlp->nlp_backup_path, nlp->nlp_clevel);
1724 		return (NDMP_NO_MEM_ERR);
1725 	}
1726 
1727 	NDMP_LOG(LOG_DEBUG,
1728 	    "Date of this level %d on \"%s\": %s",
1729 	    nlp->nlp_clevel, nlp->nlp_backup_path, cctime(&nlp->nlp_cdate));
1730 	NDMP_LOG(LOG_DEBUG,
1731 	    "Date of last level %d on \"%s\": %s",
1732 	    nlp->nlp_llevel, nlp->nlp_backup_path, cctime(&nlp->nlp_ldate));
1733 
1734 	/* Should the dumpdate file be updated? */
1735 	cp = MOD_GETENV(params, "UPDATE");
1736 	if (cp == NULL) {
1737 		NDMP_LOG(LOG_DEBUG,
1738 		    "env(UPDATE) not specified, default to TRUE");
1739 		NLP_SET(nlp, NLPF_UPDATE);
1740 	} else {
1741 		NDMP_LOG(LOG_DEBUG, "env(UPDATE): \"%s\"", cp);
1742 		if (strchr("t_ty_y", *cp) != NULL)
1743 			NLP_SET(nlp, NLPF_UPDATE);
1744 		else
1745 			NLP_UNSET(nlp, NLPF_UPDATE);
1746 	}
1747 
1748 	return (NDMP_NO_ERR);
1749 }
1750 
1751 
1752 
1753 /*
1754  * log_bk_params_v2
1755  *
1756  * Dump the value of the parameters in the log file for debugging.
1757  */
1758 void
1759 log_bk_params_v2(ndmpd_session_t *session, ndmpd_module_params_t *params,
1760     ndmp_lbr_params_t *nlp)
1761 {
1762 	MOD_LOG(params, "Date of this level %d on \"%s\": %s\n",
1763 	    nlp->nlp_clevel, nlp->nlp_backup_path, cctime(&nlp->nlp_cdate));
1764 	MOD_LOG(params, "Date of last level %d on \"%s\": %s\n",
1765 	    nlp->nlp_llevel, nlp->nlp_backup_path, cctime(&nlp->nlp_ldate));
1766 
1767 	MOD_LOG(params, "Backing up: \"%s\".\n", nlp->nlp_backup_path);
1768 	MOD_LOG(params, "Record size: %d\n", session->ns_mover.md_record_size);
1769 	MOD_LOG(params, "File history: %c.\n",
1770 	    NDMP_YORN(NLP_ISSET(nlp, NLPF_FH)));
1771 	MOD_LOG(params, "Update: %s\n",
1772 	    NLP_ISSET(nlp, NLPF_UPDATE) ? "TRUE" : "FALSE");
1773 
1774 }
1775 
1776 
1777 /*
1778  * same_path
1779  *
1780  * Find out if the paths are the same regardless of the ending slash
1781  *
1782  * Examples :
1783  *   /a/b/c == /a/b/c
1784  *   /a/b/c/ == /a/b/c
1785  *   /a/b/c == /a/b/c/
1786  */
1787 static boolean_t
1788 same_path(char *s, char *t)
1789 {
1790 	boolean_t rv;
1791 	int slen, tlen;
1792 
1793 	rv = FALSE;
1794 	slen = strlen(s);
1795 	tlen = strlen(t);
1796 	if (slen == tlen && strcmp(s, t) == 0) {
1797 		rv = TRUE;
1798 	} else {
1799 		if (slen == tlen - 1) {
1800 			if (strncmp(s, t, slen) == 0 && t[tlen - 1] == '/')
1801 				rv = TRUE;
1802 		} else if (tlen == slen -1) {
1803 			if (strncmp(s, t, tlen) == 0 && s[slen - 1] == '/')
1804 				rv = TRUE;
1805 		}
1806 	}
1807 
1808 	NDMP_LOG(LOG_DEBUG, "rv: %d", rv);
1809 	return (rv);
1810 }
1811 
1812 
1813 /*
1814  * ndmp_restore_extract_params
1815  *
1816  * Go through the restore parameters and check them and extract them
1817  * by setting NLP flags and other values.
1818  *
1819  * Parameters:
1820  *
1821  * Returns:
1822  *   0: on success
1823  *  -1: otherwise
1824  */
1825 int
1826 ndmp_restore_extract_params(ndmpd_session_t *session,
1827     ndmpd_module_params_t *params)
1828 {
1829 	char *bkpath, *rspath;
1830 	ndmp_lbr_params_t *nlp;
1831 
1832 	if ((nlp = ndmp_get_nlp(session)) == NULL) {
1833 		NDMP_LOG(LOG_DEBUG, "nlp == NULL");
1834 		return (-1);
1835 	}
1836 
1837 	/* Extract directory from where the backup was made. */
1838 	if ((bkpath = get_backup_path(params)) == NULL)
1839 		return (NDMP_ILLEGAL_ARGS_ERR);
1840 
1841 	nlp->nlp_restore_bk_path = bkpath;
1842 
1843 	/* The number of the selections. */
1844 	if ((nlp->nlp_nfiles = get_nfiles(session, params)) == 0)
1845 		return (NDMP_ILLEGAL_ARGS_ERR);
1846 
1847 	NDMP_LOG(LOG_DEBUG, "nfiles: %d", nlp->nlp_nfiles);
1848 
1849 	if ((rspath = get_restore_dest(params)) == NULL)
1850 		return (NDMP_ILLEGAL_ARGS_ERR);
1851 
1852 	if (fs_is_rdonly(rspath)) {
1853 		MOD_LOG(params,
1854 		    "Error: Can't restore to a read-only volume: \"%s\"\n",
1855 		    rspath);
1856 		return (NDMP_ILLEGAL_ARGS_ERR);
1857 	}
1858 	if (fs_is_chkpntvol(rspath)) {
1859 		MOD_LOG(params,
1860 		    "Error: Can't restore to a checkpoint: \"%s\"\n", rspath);
1861 		return (NDMP_ILLEGAL_ARGS_ERR);
1862 	}
1863 
1864 	if (same_path(bkpath, rspath))
1865 		rspath = "";
1866 
1867 	if ((nlp->nlp_restore_path = strdup(rspath)) == NULL)
1868 		return (NDMP_NO_MEM_ERR);
1869 
1870 	bkpath = trim_name(bkpath);
1871 	if (correct_ents(params, nlp->nlp_nfiles, bkpath) < 0) {
1872 		free(nlp->nlp_restore_path);
1873 		return (NDMP_ILLEGAL_ARGS_ERR);
1874 	}
1875 
1876 	if (check_restore_paths(params, nlp->nlp_nfiles, rspath) < 0) {
1877 		free(nlp->nlp_restore_path);
1878 		return (NDMP_ILLEGAL_ARGS_ERR);
1879 	}
1880 
1881 	MOD_LOG(params, "Restoring %d files.\n", nlp->nlp_nfiles);
1882 	MOD_LOG(params, "Restoring to: \"%s\".\n", nlp->nlp_restore_path);
1883 	MOD_LOG(params, "Record size: %d\n", session->ns_mover.md_record_size);
1884 
1885 	return (NDMP_NO_ERR);
1886 }
1887 
1888 /*
1889  * ndmpd_tar_backup_starter (V2 only)
1890  *
1891  * The main backup starter function. It creates a snapshot if necessary
1892  * and calls ndmp_tar_backup to perform the actual backup. It does the cleanup
1893  * and release the snapshot at the end.
1894  */
1895 int
1896 ndmpd_tar_backup_starter(ndmpd_module_params_t *mod_params)
1897 {
1898 	int err;
1899 	ndmpd_session_t *session;
1900 	ndmp_lbr_params_t *nlp;
1901 
1902 	session = (ndmpd_session_t *)(mod_params->mp_daemon_cookie);
1903 	*(mod_params->mp_module_cookie) = nlp = ndmp_get_nlp(session);
1904 	ndmp_session_ref(session);
1905 
1906 	err = 0;
1907 	if (fs_is_chkpntvol(nlp->nlp_backup_path) ||
1908 	    fs_is_rdonly(nlp->nlp_backup_path) ||
1909 	    !fs_is_chkpnt_enabled(nlp->nlp_backup_path))
1910 		NLP_SET(nlp, NLPF_CHKPNTED_PATH);
1911 	else {
1912 		NLP_UNSET(nlp, NLPF_CHKPNTED_PATH);
1913 		if (ndmp_start_check_point(nlp->nlp_backup_path,
1914 		    nlp->nlp_jstat->js_job_name) < 0) {
1915 			MOD_LOG(mod_params,
1916 			    "Error: creating checkpoint on %s\n",
1917 			    nlp->nlp_backup_path);
1918 			/* -1 causes halt reason to become internal error. */
1919 			err = -1;
1920 		}
1921 	}
1922 
1923 	NDMP_LOG(LOG_DEBUG, "NLPF_CHKPNTED_PATH: %c",
1924 	    NDMP_YORN(NLP_ISCHKPNTED(nlp)));
1925 	NDMP_LOG(LOG_DEBUG, "err: %d, update %c",
1926 	    err, NDMP_YORN(NLP_SHOULD_UPDATE(nlp)));
1927 
1928 	if (err == 0) {
1929 		err = ndmp_get_cur_bk_time(nlp, &nlp->nlp_cdate,
1930 		    nlp->nlp_jstat->js_job_name);
1931 		if (err != 0) {
1932 			NDMP_LOG(LOG_DEBUG, "err %d", err);
1933 		} else {
1934 			log_bk_params_v2(session, mod_params, nlp);
1935 			err = ndmpd_tar_backup(session, mod_params, nlp);
1936 		}
1937 	}
1938 
1939 	if (nlp->nlp_bkmap >= 0) {
1940 		(void) dbm_free(nlp->nlp_bkmap);
1941 		nlp->nlp_bkmap = -1;
1942 	}
1943 
1944 	if (!NLP_ISCHKPNTED(nlp))
1945 		(void) ndmp_release_check_point(nlp->nlp_backup_path,
1946 		    nlp->nlp_jstat->js_job_name);
1947 
1948 	NDMP_LOG(LOG_DEBUG, "err %d, update %c",
1949 	    err, NDMP_YORN(NLP_SHOULD_UPDATE(nlp)));
1950 
1951 	if (err == 0 && NLP_SHOULD_UPDATE(nlp)) {
1952 		if (ndmpd_put_dumptime(nlp->nlp_backup_path, nlp->nlp_clevel,
1953 		    nlp->nlp_cdate) < 0) {
1954 			err = EPERM;
1955 			MOD_LOG(mod_params,
1956 			    "Error: updating the dumpdates file on %s\n",
1957 			    nlp->nlp_backup_path);
1958 		}
1959 	}
1960 
1961 	MOD_DONE(mod_params, err);
1962 
1963 	/* nlp_params is allocated in start_backup() */
1964 	NDMP_FREE(nlp->nlp_params);
1965 
1966 	NS_DEC(nbk);
1967 	ndmp_session_unref(session);
1968 	return (err);
1969 }
1970 
1971 
1972 /*
1973  * ndmpd_tar_backup_abort
1974  *
1975  * Abort the running backup by stopping the reader thread (V2 only)
1976  */
1977 int
1978 ndmpd_tar_backup_abort(void *module_cookie)
1979 {
1980 	ndmp_lbr_params_t *nlp;
1981 
1982 	nlp = (ndmp_lbr_params_t *)module_cookie;
1983 	if (nlp != NULL && nlp->nlp_session != NULL) {
1984 		if (nlp->nlp_session->ns_data.dd_mover.addr_type ==
1985 		    NDMP_ADDR_TCP && nlp->nlp_session->ns_data.dd_sock != -1) {
1986 			(void) close(nlp->nlp_session->ns_data.dd_sock);
1987 			nlp->nlp_session->ns_data.dd_sock = -1;
1988 		}
1989 		ndmp_stop_reader_thread(nlp->nlp_session);
1990 	}
1991 
1992 	return (0);
1993 }
1994 
1995 /*
1996  * ndmpd_tar_restore_starter
1997  *
1998  * Starts the restore by running ndmpd_tar_restore function (V2 only)
1999  */
2000 
2001 int
2002 ndmpd_tar_restore_starter(ndmpd_module_params_t *mod_params)
2003 {
2004 	int err;
2005 	ndmpd_session_t *session;
2006 	ndmp_lbr_params_t *nlp;
2007 
2008 	session = (ndmpd_session_t *)(mod_params->mp_daemon_cookie);
2009 	*(mod_params->mp_module_cookie) = nlp = ndmp_get_nlp(session);
2010 	ndmp_session_ref(session);
2011 
2012 	err = ndmpd_tar_restore(session, mod_params, nlp);
2013 	MOD_DONE(mod_params, err);
2014 
2015 	/* nlp_params is allocated in start_recover() */
2016 	NDMP_FREE(nlp->nlp_params);
2017 
2018 	NS_DEC(nrs);
2019 	ndmp_session_unref(session);
2020 	return (err);
2021 }
2022 
2023 
2024 /*
2025  * ndmpd_tar_restore_abort
2026  *
2027  * Aborts the restore operation by stopping the writer thread (V2 only)
2028  */
2029 int
2030 ndmpd_tar_restore_abort(void *module_cookie)
2031 {
2032 	ndmp_lbr_params_t *nlp;
2033 
2034 	nlp = (ndmp_lbr_params_t *)module_cookie;
2035 	if (nlp != NULL && nlp->nlp_session != NULL) {
2036 		if (nlp->nlp_session->ns_data.dd_mover.addr_type ==
2037 		    NDMP_ADDR_TCP && nlp->nlp_session->ns_data.dd_sock != -1) {
2038 			(void) close(nlp->nlp_session->ns_data.dd_sock);
2039 			nlp->nlp_session->ns_data.dd_sock = -1;
2040 		}
2041 		nlp_event_nw(nlp->nlp_session);
2042 		ndmp_stop_writer_thread(nlp->nlp_session);
2043 	}
2044 
2045 	return (0);
2046 }
2047