1 /*
2 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2015 by Delphix. All rights reserved.
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 #include <sys/errno.h>
40 #include <ctype.h>
41 #include <stdlib.h>
42 #include <time.h>
43 #include <sys/types.h>
44 #include <unistd.h>
45 #include <libzfs.h>
46 #include <pthread.h>
47 #include "tlm.h"
48 #include "tlm_proto.h"
49 #include <ndmpd_prop.h>
50 #include <sys/mtio.h>
51 #include <sys/mnttab.h>
52 #include <sys/mntent.h>
53 #include <sys/statvfs.h>
54 #include <sys/scsi/impl/uscsi.h>
55 #include <sys/scsi/scsi.h>
56 #include <sys/mtio.h>
57 #include <thread.h>
58 #include <synch.h>
59 #include <sys/mutex.h>
60 #include <sys/sysmacros.h>
61 #include <sys/mkdev.h>
62
63 /*
64 * Tar archiving ops vector
65 */
66 tm_ops_t tm_tar_ops = {
67 "tar",
68 tar_putfile,
69 tar_putdir,
70 NULL,
71 tar_getfile,
72 tar_getdir,
73 NULL
74 };
75
76 extern libzfs_handle_t *zlibh;
77 extern mutex_t zlib_mtx;
78
79 /*
80 * get the next tape buffer from the drive's pool of buffers
81 */
82 /*ARGSUSED*/
83 char *
84 tlm_get_write_buffer(long want, long *actual_size,
85 tlm_buffers_t *buffers, int zero)
86 {
87 int buf = buffers->tbs_buffer_in;
88 tlm_buffer_t *buffer = &buffers->tbs_buffer[buf];
89 int align_size = RECORDSIZE - 1;
90 char *rec;
91
92 /*
93 * make sure the allocation is in chunks of 512 bytes
94 */
95 want += align_size;
96 want &= ~align_size;
97
98 *actual_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
99 if (*actual_size <= 0) {
100 /*
101 * no room, send this one
102 * and wait for a free one
103 */
104 if (!buffer->tb_full) {
105 /*
106 * we are now ready to send a full buffer
107 * instead of trying to get a new buffer
108 *
109 * do not send if we failed to get a buffer
110 * on the previous call
111 */
112 buffer->tb_full = TRUE;
113
114 /*
115 * tell the writer that a buffer is available
116 */
117 tlm_buffer_release_in_buf(buffers);
118
119 buffer = tlm_buffer_advance_in_idx(buffers);
120 }
121
122 buffer = tlm_buffer_in_buf(buffers, NULL);
123
124 if (buffer->tb_full) {
125 /*
126 * wait for the writer to free up a buffer
127 */
128 tlm_buffer_out_buf_timed_wait(buffers, 500);
129 }
130
131 buffer = tlm_buffer_in_buf(buffers, NULL);
132 if (buffer->tb_full) {
133 /*
134 * the next buffer is still full
135 * of data from previous activity
136 *
137 * nothing has changed.
138 */
139 return (0);
140 }
141
142 buffer->tb_buffer_spot = 0;
143 *actual_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
144 }
145
146 *actual_size = min(want, *actual_size);
147 rec = &buffer->tb_buffer_data[buffer->tb_buffer_spot];
148 buffer->tb_buffer_spot += *actual_size;
149 buffers->tbs_offset += *actual_size;
150 if (zero) {
151 (void) memset(rec, 0, *actual_size);
152 }
153 return (rec);
154 }
155
156 /*
157 * get a read record from the tape buffer,
158 * and read a tape block if necessary
159 */
160 /*ARGSUSED*/
161 char *
162 tlm_get_read_buffer(int want, int *error,
163 tlm_buffers_t *buffers, int *actual_size)
164 {
165 tlm_buffer_t *buffer;
166 int align_size = RECORDSIZE - 1;
167 int buf;
168 int current_size;
169 char *rec;
170
171 buf = buffers->tbs_buffer_out;
172 buffer = &buffers->tbs_buffer[buf];
173
174 /*
175 * make sure the allocation is in chunks of 512 bytes
176 */
177 want += align_size;
178 want &= ~align_size;
179
180 current_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
181 if (buffer->tb_full && current_size <= 0) {
182 /*
183 * no more data, release this
184 * one and go get another
185 */
186
187 /*
188 * tell the reader that a buffer is available
189 */
190 buffer->tb_full = FALSE;
191 tlm_buffer_release_out_buf(buffers);
192
193 buffer = tlm_buffer_advance_out_idx(buffers);
194 current_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
195 }
196
197 if (!buffer->tb_full) {
198 /*
199 * next buffer is not full yet.
200 * wait for the reader.
201 */
202 tlm_buffer_in_buf_timed_wait(buffers, 500);
203
204 buffer = tlm_buffer_out_buf(buffers, NULL);
205 if (!buffer->tb_full) {
206 /*
207 * we do not have anything from the tape yet
208 */
209 return (0);
210 }
211
212 current_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
213 }
214
215 /* Make sure we got something */
216 if (current_size <= 0)
217 return (NULL);
218
219 current_size = min(want, current_size);
220 rec = &buffer->tb_buffer_data[buffer->tb_buffer_spot];
221 buffer->tb_buffer_spot += current_size;
222 *actual_size = current_size;
223
224 /*
225 * the error flag is only sent back one time,
226 * since the flag refers to a previous read
227 * attempt, not the data in this buffer.
228 */
229 *error = buffer->tb_errno;
230
231 return (rec);
232 }
233
234
235 /*
236 * unread a previously read buffer back to the tape buffer
237 */
238 void
239 tlm_unget_read_buffer(tlm_buffers_t *buffers, int size)
240 {
241 tlm_buffer_t *buffer;
242 int align_size = RECORDSIZE - 1;
243 int buf;
244 int current_size;
245
246 buf = buffers->tbs_buffer_out;
247 buffer = &buffers->tbs_buffer[buf];
248
249 /*
250 * make sure the allocation is in chunks of 512 bytes
251 */
252 size += align_size;
253 size &= ~align_size;
254
255 current_size = min(size, buffer->tb_buffer_spot);
256 buffer->tb_buffer_spot -= current_size;
257 }
258
259
260 /*
261 * unwrite a previously written buffer
262 */
263 void
264 tlm_unget_write_buffer(tlm_buffers_t *buffers, int size)
265 {
266 tlm_buffer_t *buffer;
267 int align_size = RECORDSIZE - 1;
268 int buf;
269 int current_size;
270
271 buf = buffers->tbs_buffer_in;
272 buffer = &buffers->tbs_buffer[buf];
273
274 /*
275 * make sure the allocation is in chunks of 512 bytes
276 */
277 size += align_size;
278 size &= ~align_size;
279
280 current_size = min(size, buffer->tb_buffer_spot);
281 buffer->tb_buffer_spot -= current_size;
282 }
283
284
285 /*
286 * build a checksum for a TAR header record
287 */
288 void
289 tlm_build_header_checksum(tlm_tar_hdr_t *r)
290 {
291 int i;
292 int sum = 0;
293 char *c = (char *)r;
294
295 (void) memcpy(r->th_chksum, CHKBLANKS, strlen(CHKBLANKS));
296 for (i = 0; i < RECORDSIZE; i++) {
297 sum += c[i] & 0xFF;
298 }
299 (void) snprintf(r->th_chksum, sizeof (r->th_chksum), "%6o", sum);
300 }
301
302 /*
303 * verify the tar header checksum
304 */
305 int
306 tlm_vfy_tar_checksum(tlm_tar_hdr_t *tar_hdr)
307 {
308 int chksum = oct_atoi(tar_hdr->th_chksum);
309 uchar_t *p = (uchar_t *)tar_hdr;
310 int sum = 0; /* initial value of checksum */
311 int i; /* loop counter */
312
313 /*
314 * compute the checksum
315 */
316 for (i = 0; i < RECORDSIZE; i++) {
317 sum += p[i] & 0xFF;
318 }
319
320 if (sum == 0) {
321 NDMP_LOG(LOG_DEBUG,
322 "should be %d, is 0", chksum);
323 /* a zero record ==> end of tar file */
324 return (0);
325 }
326
327 /*
328 * subtract out the label's checksum values
329 * this lets us undo the old checksum "in-
330 * place", no need to swap blanks in and out
331 */
332 for (i = 0; i < 8; i++) {
333 sum -= 0xFF & tar_hdr->th_chksum[i];
334 }
335
336 /*
337 * replace the old checksum field with blanks
338 */
339 sum += ' ' * 8;
340
341 if (sum != chksum)
342 NDMP_LOG(LOG_DEBUG,
343 "should be %d, is %d", chksum, sum);
344
345 return ((sum == chksum) ? 1 : -1);
346 }
347
348 /*
349 * get internal scsi_sasd entry for this tape drive
350 */
351 int
352 tlm_get_scsi_sasd_entry(int lib, int drv)
353 {
354 int entry;
355 int i, n;
356 scsi_link_t *sl;
357 tlm_drive_t *dp;
358
359 entry = -1;
360 dp = tlm_drive(lib, drv);
361 if (!dp) {
362 NDMP_LOG(LOG_DEBUG, "NULL dp for (%d.%d)", lib, drv);
363 } else if (!dp->td_slink) {
364 NDMP_LOG(LOG_DEBUG, "NULL dp->td_slink for (%d.%d)", lib, drv);
365 } else if (!dp->td_slink->sl_sa) {
366 NDMP_LOG(LOG_DEBUG, "NULL dp->td_slink->sl_sa for (%d.%d)",
367 lib, drv);
368 } else {
369 /* search through the SASD table */
370 n = sasd_dev_count();
371 for (i = 0; i < n; i++) {
372 sl = sasd_dev_slink(i);
373 if (!sl)
374 continue;
375
376 if (dp->td_slink->sl_sa == sl->sl_sa &&
377 dp->td_scsi_id == sl->sl_sid &&
378 dp->td_lun == sl->sl_lun) {
379 /* all 3 variables match */
380 entry = i;
381 break;
382 }
383 }
384 }
385
386 return (entry);
387 }
388
389 /*
390 * get the OS device name for this tape
391 */
392 char *
393 tlm_get_tape_name(int lib, int drv)
394 {
395 int entry;
396
397 entry = tlm_get_scsi_sasd_entry(lib, drv);
398 if (entry >= 0) {
399 sasd_drive_t *sd;
400
401 if ((sd = sasd_drive(entry)) != 0)
402 return (sd->sd_name);
403 }
404
405 return ("");
406 }
407
408 /*
409 * create the IPC area between the reader and writer
410 */
411 tlm_cmd_t *
412 tlm_create_reader_writer_ipc(boolean_t write, long data_transfer_size)
413 {
414 tlm_cmd_t *cmd;
415
416 cmd = ndmp_malloc(sizeof (tlm_cmd_t));
417 if (cmd == NULL)
418 return (NULL);
419
420 cmd->tc_reader = TLM_BACKUP_RUN;
421 cmd->tc_writer = TLM_BACKUP_RUN;
422 cmd->tc_ref = 1;
423
424 cmd->tc_buffers = tlm_allocate_buffers(write, data_transfer_size);
425 if (cmd->tc_buffers == NULL) {
426 free(cmd);
427 return (NULL);
428 }
429
430 (void) mutex_init(&cmd->tc_mtx, 0, NULL);
431 (void) cond_init(&cmd->tc_cv, 0, NULL);
432
433 return (cmd);
434 }
435
436 /*
437 * release(destroy) the IPC between the reader and writer
438 */
439 void
440 tlm_release_reader_writer_ipc(tlm_cmd_t *cmd)
441 {
442 if (--cmd->tc_ref <= 0) {
443 (void) mutex_lock(&cmd->tc_mtx);
444 tlm_release_buffers(cmd->tc_buffers);
445 (void) cond_destroy(&cmd->tc_cv);
446 (void) mutex_unlock(&cmd->tc_mtx);
447 (void) mutex_destroy(&cmd->tc_mtx);
448 free(cmd);
449 }
450 }
451
452
453 /*
454 * NDMP support begins here.
455 */
456
457 /*
458 * Initialize the file history callback functions
459 */
460 lbr_fhlog_call_backs_t *
461 lbrlog_callbacks_init(void *cookie, path_hist_func_t log_pname_func,
462 dir_hist_func_t log_dir_func, node_hist_func_t log_node_func)
463 {
464 lbr_fhlog_call_backs_t *p;
465
466 p = ndmp_malloc(sizeof (lbr_fhlog_call_backs_t));
467 if (p == NULL)
468 return (NULL);
469
470 p->fh_cookie = cookie;
471 p->fh_logpname = (func_t)log_pname_func;
472 p->fh_log_dir = (func_t)log_dir_func;
473 p->fh_log_node = (func_t)log_node_func;
474 return (p);
475 }
476
477 /*
478 * Cleanup the callbacks
479 */
480 void
481 lbrlog_callbacks_done(lbr_fhlog_call_backs_t *p)
482 {
483 if (p != NULL)
484 (void) free((char *)p);
485 }
486
487 /*
488 * Call back for file history directory info
489 */
490 int
491 tlm_log_fhdir(tlm_job_stats_t *job_stats, char *dir, struct stat64 *stp,
492 fs_fhandle_t *fhp)
493 {
494 int rv;
495 lbr_fhlog_call_backs_t *cbp; /* callbacks pointer */
496
497 rv = 0;
498 if (job_stats == NULL) {
499 NDMP_LOG(LOG_DEBUG, "log_fhdir: jstat is NULL");
500 } else if (dir == NULL) {
501 NDMP_LOG(LOG_DEBUG, "log_fhdir: dir is NULL");
502 } else if (stp == NULL) {
503 NDMP_LOG(LOG_DEBUG, "log_fhdir: stp is NULL");
504 } else if ((cbp = (lbr_fhlog_call_backs_t *)job_stats->js_callbacks)
505 == NULL) {
506 NDMP_LOG(LOG_DEBUG, "log_fhdir: cbp is NULL");
507 } else if (cbp->fh_log_dir == NULL) {
508 NDMP_LOG(LOG_DEBUG, "log_fhdir: callback is NULL");
509 } else
510 rv = (*cbp->fh_log_dir)(cbp, dir, stp, fhp);
511
512 return (rv);
513 }
514
515 /*
516 * Call back for file history node info
517 */
518 int
519 tlm_log_fhnode(tlm_job_stats_t *job_stats, char *dir, char *file,
520 struct stat64 *stp, u_longlong_t off)
521 {
522 int rv;
523 lbr_fhlog_call_backs_t *cbp; /* callbacks pointer */
524
525 rv = 0;
526 if (job_stats == NULL) {
527 NDMP_LOG(LOG_DEBUG, "log_fhnode: jstat is NULL");
528 } else if (dir == NULL) {
529 NDMP_LOG(LOG_DEBUG, "log_fhnode: dir is NULL");
530 } else if (file == NULL) {
531 NDMP_LOG(LOG_DEBUG, "log_fhnode: file is NULL");
532 } else if (stp == NULL) {
533 NDMP_LOG(LOG_DEBUG, "log_fhnode: stp is NULL");
534 } else if ((cbp = (lbr_fhlog_call_backs_t *)job_stats->js_callbacks)
535 == NULL) {
536 NDMP_LOG(LOG_DEBUG, "log_fhnode: cbp is NULL");
537 } else if (cbp->fh_log_node == NULL) {
538 NDMP_LOG(LOG_DEBUG, "log_fhnode: callback is NULL");
539 } else
540 rv = (*cbp->fh_log_node)(cbp, dir, file, stp, off);
541
542 return (rv);
543 }
544
545 /*
546 * Call back for file history path info
547 */
548 int
549 tlm_log_fhpath_name(tlm_job_stats_t *job_stats, char *pathname,
550 struct stat64 *stp, u_longlong_t off)
551 {
552 int rv;
553 lbr_fhlog_call_backs_t *cbp; /* callbacks pointer */
554
555 rv = 0;
556 if (!job_stats) {
557 NDMP_LOG(LOG_DEBUG, "log_fhpath_name: jstat is NULL");
558 } else if (!pathname) {
559 NDMP_LOG(LOG_DEBUG, "log_fhpath_name: pathname is NULL");
560 } else if (!stp) {
561 NDMP_LOG(LOG_DEBUG, "log_fhpath_name: stp is NULL");
562 } else if ((cbp = (lbr_fhlog_call_backs_t *)job_stats->js_callbacks)
563 == 0) {
564 NDMP_LOG(LOG_DEBUG, "log_fhpath_name: cbp is NULL");
565 } else if (!cbp->fh_logpname) {
566 NDMP_LOG(LOG_DEBUG, "log_fhpath_name: callback is NULL");
567 } else
568 rv = (*cbp->fh_logpname)(cbp, pathname, stp, off);
569
570 return (rv);
571 }
572
573
574 /*
575 * Log call back to report the entry recovery
576 */
577 int
578 tlm_entry_restored(tlm_job_stats_t *job_stats, char *name, int pos)
579 {
580 lbr_fhlog_call_backs_t *cbp; /* callbacks pointer */
581
582 NDMP_LOG(LOG_DEBUG, "name: \"%s\", pos: %d", name, pos);
583
584 if (job_stats == NULL) {
585 NDMP_LOG(LOG_DEBUG, "entry_restored: jstat is NULL");
586 return (0);
587 }
588 cbp = (lbr_fhlog_call_backs_t *)job_stats->js_callbacks;
589 if (cbp == NULL) {
590 NDMP_LOG(LOG_DEBUG, "entry_restored is NULL");
591 return (0);
592 }
593 return (*cbp->fh_logpname)(cbp, name, 0, (longlong_t)pos);
594 }
595 /*
596 * NDMP support ends here.
597 */
598
599 /*
600 * Function: tlm_cat_path
601 * Concatenates two path names
602 * or directory name and file name
603 * into a buffer passed by the caller. A slash
604 * is inserted if required. Buffer is assumed
605 * to hold PATH_MAX characters.
606 *
607 * Parameters:
608 * char *buf - buffer to write new dir/name string
609 * char *dir - directory name
610 * char *name - file name
611 *
612 * Returns:
613 * TRUE - No errors. buf contains the dir/name string
614 * FALSE - Error. buf is not modified.
615 */
616 boolean_t
617 tlm_cat_path(char *buf, char *dir, char *name)
618 {
619 char *fmt;
620 int dirlen = strlen(dir);
621 int filelen = strlen(name);
622
623 if ((dirlen + filelen + 1) >= PATH_MAX) {
624 return (FALSE);
625 }
626
627 if (*dir == '\0' || *name == '\0' || dir[dirlen - 1] == '/' ||
628 *name == '/') {
629 fmt = "%s%s";
630 } else {
631 fmt = "%s/%s";
632 }
633
634 /* check for ".../" and "/...." */
635 if ((dirlen > 0) && (dir[dirlen - 1] == '/') && (*name == '/'))
636 name += strspn(name, "/");
637
638 /* LINTED variable format */
639 (void) snprintf(buf, TLM_MAX_PATH_NAME, fmt, dir, name);
640
641 return (TRUE);
642 }
643
644 /*
645 * Get the checkpoint (snapshot) creation time.
646 * This is necessary to check for checkpoints not being stale.
647 */
648 int
649 tlm_get_chkpnt_time(char *path, int auto_checkpoint, time_t *tp, char *jname)
650 {
651 char volname[TLM_VOLNAME_MAX_LENGTH];
652 char chk_name[PATH_MAX];
653 char *cp_nm;
654
655 NDMP_LOG(LOG_DEBUG, "path [%s] auto_checkpoint: %d",
656 path, auto_checkpoint);
657
658 if (path == NULL || *path == '\0' || tp == NULL)
659 return (-1);
660
661 if (get_zfsvolname(volname, TLM_VOLNAME_MAX_LENGTH,
662 path) == -1)
663 return (-1);
664
665 if (auto_checkpoint) {
666 NDMP_LOG(LOG_DEBUG, "volname [%s]", volname);
667 (void) snprintf(chk_name, PATH_MAX, "%s", jname);
668 return (chkpnt_creationtime_bypattern(volname, chk_name, tp));
669 }
670 cp_nm = strchr(volname, '@');
671 NDMP_LOG(LOG_DEBUG, "volname [%s] cp_nm [%s]", volname, cp_nm);
672
673 return (chkpnt_creationtime_bypattern(volname, cp_nm, tp));
674 }
675
676 /*
677 * Release an array of pointers and the pointers themselves.
678 */
679 void
680 tlm_release_list(char **lpp)
681 {
682 char **save;
683
684 if ((save = lpp) == 0)
685 return;
686
687 while (*lpp)
688 free(*lpp++);
689
690 free(save);
691 }
692
693 /*
694 * Print the list of array of strings in the backup log
695 */
696 void
697 tlm_log_list(char *title, char **lpp)
698 {
699 int i;
700
701 if (!lpp)
702 return;
703
704 NDMP_LOG(LOG_DEBUG, "%s:", title);
705
706 for (i = 0; *lpp; lpp++, i++)
707 NDMP_LOG(LOG_DEBUG, "%d: [%s]", i, *lpp);
708 }
709
710 /*
711 * Insert the backup snapshot name into the path.
712 *
713 * Input:
714 * name: Original path name.
715 *
716 * Output:
717 * name: Original name modified to include a snapshot.
718 *
719 * Returns:
720 * Original name modified to include a snapshot.
721 */
722 char *
723 tlm_build_snapshot_name(char *name, char *sname, char *jname)
724 {
725 zfs_handle_t *zhp;
726 char *rest;
727 char volname[ZFS_MAX_DATASET_NAME_LEN];
728 char mountpoint[PATH_MAX];
729
730 if (get_zfsvolname(volname, ZFS_MAX_DATASET_NAME_LEN, name) == -1)
731 goto notzfs;
732
733 (void) mutex_lock(&zlib_mtx);
734 if ((zlibh == NULL) ||
735 (zhp = zfs_open(zlibh, volname, ZFS_TYPE_DATASET)) == NULL) {
736 (void) mutex_unlock(&zlib_mtx);
737 goto notzfs;
738 }
739
740 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, PATH_MAX, NULL,
741 NULL, 0, B_FALSE) != 0) {
742 zfs_close(zhp);
743 (void) mutex_unlock(&zlib_mtx);
744 goto notzfs;
745 }
746
747 zfs_close(zhp);
748 (void) mutex_unlock(&zlib_mtx);
749
750 rest = name + strlen(mountpoint);
751 (void) snprintf(sname, TLM_MAX_PATH_NAME, "%s/%s/%s%s", mountpoint,
752 TLM_SNAPSHOT_DIR, jname, rest);
753
754 return (sname);
755
756 notzfs:
757 (void) strlcpy(sname, name, TLM_MAX_PATH_NAME);
758 return (sname);
759 }
760
761 /*
762 * Remove the checkpoint from a path name.
763 *
764 * Input:
765 * name: Full pathname with checkpoint embeded.
766 *
767 * Output:
768 * unchkp_name: real pathname with no checkpoint.
769 *
770 * Returns:
771 * Pointer to the un-checkpointed path.
772 */
773 char *
774 tlm_remove_checkpoint(char *name, char *unchkp_name)
775 {
776 char *cp;
777 int i;
778 int plen;
779
780 unchkp_name[0] = name[0];
781 plen = strlen(TLM_SNAPSHOT_PREFIX);
782 for (i = 1; i <= TLM_VOLNAME_MAX_LENGTH + 1; i++) {
783 switch (name[i]) {
784 case '.':
785 if (strncmp(&name[i], TLM_SNAPSHOT_PREFIX,
786 plen) == 0) {
787 unchkp_name[i] = '\0';
788 i += plen;
789 if (name[i] == '\0') {
790 /*
791 * name == "/v1.chkpnt"
792 */
793 return (unchkp_name);
794 }
795 if ((cp = strchr(&name[++i], '/')) != NULL) {
796 (void) strlcat(unchkp_name, cp,
797 TLM_VOLNAME_MAX_LENGTH + 1);
798 }
799 return (unchkp_name);
800 } else {
801 unchkp_name[i] = name[i];
802 }
803 break;
804 case '/':
805 return (name);
806 case 0:
807 return (name);
808 default:
809 unchkp_name[i] = name[i];
810 break;
811 }
812 }
813 return (name);
814 }
815
816 /*
817 * see if we should exclude this file.
818 */
819 boolean_t
820 tlm_is_excluded(char *dir, char *name, char **excl_files)
821 {
822 int i;
823 char full_name[TLM_MAX_PATH_NAME];
824
825 if (!dir || !name || !excl_files)
826 return (FALSE);
827
828 if (!tlm_cat_path(full_name, dir, name)) {
829 NDMP_LOG(LOG_DEBUG, "Path too long [%s][%s]",
830 dir, name);
831 return (FALSE);
832 }
833 for (i = 0; excl_files[i] != 0; i++) {
834 if (match(excl_files[i], full_name)) {
835 return (TRUE);
836 }
837 }
838 return (FALSE);
839 }
840
841 /*
842 * Check if the path is too long
843 */
844 boolean_t
845 tlm_is_too_long(int checkpointed, char *dir, char *nm)
846 {
847 int nlen, tot;
848
849 tot = 0;
850 if (dir)
851 tot += strlen(dir);
852 if (checkpointed)
853 tot += strlen(TLM_SNAPSHOT_DIR) + 1;
854 if (nm) {
855 if ((nlen = strlen(nm)) > 0)
856 tot += nlen + 1;
857 }
858 return ((tot >= PATH_MAX) ? TRUE : FALSE);
859 }
860
861 /*
862 * Get the data offset of inside the buffer
863 */
864 longlong_t
865 tlm_get_data_offset(tlm_cmd_t *lcmds)
866 {
867 if (!lcmds)
868 return (0LL);
869
870 return (lcmds->tc_buffers->tbs_offset);
871 }
872
873 /*
874 * Enable the barcode capability on the library
875 */
876 void
877 tlm_enable_barcode(int l)
878 {
879 tlm_library_t *lp;
880
881 if ((lp = tlm_library(l))) {
882 lp->tl_capability_barcodes = TRUE;
883 NDMP_LOG(LOG_DEBUG,
884 "Barcode capability on library %d enabled.", l);
885 }
886 }
887
888 /*
889 * SASD SCSI support
890 */
891 static scsi_adapter_t my_sa;
892 static int sasd_drive_count = 0;
893 static scsi_sasd_drive_t *scsi_sasd_drives[128];
894
895 /*
896 * Count of SCSI devices
897 */
898 int
899 sasd_dev_count(void)
900 {
901 return (sasd_drive_count);
902 }
903
904 /*
905 * Return the SCSI device name
906 */
907 char *
908 sasd_slink_name(scsi_link_t *slink)
909 {
910 int i;
911
912 for (i = 0; i < sasd_drive_count; i++) {
913 if (&scsi_sasd_drives[i]->ss_slink == slink)
914 return (scsi_sasd_drives[i]->ss_sd.sd_name);
915 }
916 return (NULL);
917 }
918
919 /*
920 * Return the SCSI drive structure
921 */
922 sasd_drive_t *
923 sasd_slink_drive(scsi_link_t *slink)
924 {
925 int i;
926
927 for (i = 0; i < sasd_drive_count; i++) {
928 if (&scsi_sasd_drives[i]->ss_slink == slink)
929 return (&scsi_sasd_drives[i]->ss_sd);
930 }
931 return (NULL);
932 }
933
934 /*
935 * Return the SCSI link pointer for the given index
936 */
937 scsi_link_t *
938 sasd_dev_slink(int entry)
939 {
940 scsi_link_t *rv;
941
942 if (entry >= 0 && entry < sasd_drive_count)
943 rv = &scsi_sasd_drives[entry]->ss_slink;
944 else
945 rv = NULL;
946
947 return (rv);
948 }
949
950 /*
951 * Return the SCSI drive for the given index
952 */
953 sasd_drive_t *
954 sasd_drive(int entry)
955 {
956 sasd_drive_t *rv;
957
958 if (entry >= 0 && entry < sasd_drive_count)
959 rv = &scsi_sasd_drives[entry]->ss_sd;
960 else
961 rv = NULL;
962
963 return (rv);
964 }
965
966 /*
967 * Attach the SCSI device by updating the structures
968 */
969 void
970 scsi_sasd_attach(scsi_adapter_t *sa, int sid, int lun, char *name,
971 int type)
972 {
973 scsi_link_t *sl, *next;
974 scsi_sasd_drive_t *ssd;
975
976 ssd = ndmp_malloc(sizeof (scsi_sasd_drive_t));
977 if (ssd == NULL)
978 return;
979
980 scsi_sasd_drives[sasd_drive_count++] = ssd;
981
982 switch (type) {
983 case DTYPE_CHANGER:
984 (void) snprintf(ssd->ss_sd.sd_name,
985 sizeof (ssd->ss_sd.sd_name), "%s/%s", SCSI_CHANGER_DIR,
986 name);
987 break;
988 case DTYPE_SEQUENTIAL:
989 (void) snprintf(ssd->ss_sd.sd_name,
990 sizeof (ssd->ss_sd.sd_name), "%s/%s", SCSI_TAPE_DIR, name);
991 break;
992 }
993
994 sl = &ssd->ss_slink;
995 sl->sl_type = type;
996 sl->sl_sa = sa;
997 sl->sl_lun = lun;
998 sl->sl_sid = sid;
999 sl->sl_requested_max_active = 1;
1000
1001 /* Insert slink */
1002 next = sa->sa_link_head.sl_next;
1003 sa->sa_link_head.sl_next = sl;
1004 sl->sl_next = next;
1005 }
1006
1007 /*
1008 * Go through the attached devices and detect the tape
1009 * and robot by checking the /dev entries
1010 */
1011 int
1012 probe_scsi(void)
1013 {
1014 DIR *dirp;
1015 struct dirent *dp;
1016 scsi_adapter_t *sa = &my_sa;
1017 char *p;
1018 int lun = 0;
1019 int sid = 0;
1020 char *drive_type;
1021
1022 /* Initialize the scsi adapter link */
1023 sa->sa_link_head.sl_next = &sa->sa_link_head;
1024
1025 /* Scan for the changer */
1026 dirp = opendir(SCSI_CHANGER_DIR);
1027 if (dirp == NULL) {
1028 NDMP_LOG(LOG_DEBUG,
1029 "Changer directory read error %s", SCSI_CHANGER_DIR);
1030 } else {
1031 while ((dp = readdir(dirp)) != NULL) {
1032 if ((strcmp(dp->d_name, ".") == 0) ||
1033 (strcmp(dp->d_name, "..") == 0))
1034 continue;
1035
1036 if ((p = strchr(dp->d_name, 'd')) != NULL) {
1037 lun = atoi(++p);
1038 p = strchr(dp->d_name, 't');
1039 sid = atoi(++p);
1040 }
1041 else
1042 sid = atoi(dp->d_name);
1043
1044 scsi_sasd_attach(sa, 0, lun, dp->d_name,
1045 DTYPE_CHANGER);
1046 }
1047 (void) closedir(dirp);
1048 }
1049
1050 /* Scan for tape drives */
1051 dirp = opendir(SCSI_TAPE_DIR);
1052 if (dirp == NULL) {
1053 NDMP_LOG(LOG_DEBUG,
1054 "Tape directory read error %s", SCSI_TAPE_DIR);
1055 } else {
1056 drive_type = ndmpd_get_prop(NDMP_DRIVE_TYPE);
1057
1058 if ((strcasecmp(drive_type, "sysv") != 0) &&
1059 (strcasecmp(drive_type, "bsd") != 0)) {
1060 NDMP_LOG(LOG_ERR, "Invalid ndmpd/drive-type value. "
1061 "Valid values are 'sysv' and 'bsd'.");
1062 return (-1);
1063 }
1064
1065 while ((dp = readdir(dirp)) != NULL) {
1066 if ((strcmp(dp->d_name, ".") == 0) ||
1067 (strcmp(dp->d_name, "..") == 0))
1068 continue;
1069
1070 /* Skip special modes */
1071 if (strpbrk(dp->d_name, "chlmu") != NULL)
1072 continue;
1073
1074 /* Pick the non-rewind device */
1075 if (strchr(dp->d_name, 'n') == NULL)
1076 continue;
1077
1078 if (strcasecmp(drive_type, "sysv") == 0) {
1079 if (strchr(dp->d_name, 'b') != NULL)
1080 continue;
1081 } else if (strcasecmp(drive_type, "bsd") == 0) {
1082 if (strchr(dp->d_name, 'b') == NULL)
1083 continue;
1084 }
1085
1086 sid = atoi(dp->d_name);
1087
1088 /*
1089 * SCSI ID should match with the ID of the device
1090 * (will be checked by SCSI get elements page later)
1091 */
1092 scsi_sasd_attach(sa, sid, 0, dp->d_name,
1093 DTYPE_SEQUENTIAL);
1094 }
1095 (void) closedir(dirp);
1096 }
1097
1098 return (0);
1099 }
1100
1101 /*
1102 * Get the SCSI device type (tape, robot)
1103 */
1104 /*ARGSUSED*/
1105 int
1106 scsi_get_devtype(char *adapter, int sid, int lun)
1107 {
1108 int rv;
1109 scsi_adapter_t *sa = &my_sa;
1110 scsi_link_t *sl, *sh;
1111
1112 rv = -1;
1113 sh = &sa->sa_link_head;
1114 for (sl = sh->sl_next; sl != sh; sl = sl->sl_next)
1115 if (sl->sl_sid == sid && sl->sl_lun == lun)
1116 rv = sl->sl_type;
1117
1118 return (rv);
1119 }
1120
1121
1122 /*
1123 * Check if the SCSI device exists
1124 */
1125 /*ARGSUSED*/
1126 int
1127 scsi_dev_exists(char *adapter, int sid, int lun)
1128 {
1129 scsi_adapter_t *sa = &my_sa;
1130 scsi_link_t *sl, *sh;
1131
1132 sh = &sa->sa_link_head;
1133 for (sl = sh->sl_next; sl != sh; sl = sl->sl_next)
1134 if (sl->sl_sid == sid && sl->sl_lun == lun)
1135 return (1);
1136 return (0);
1137 }
1138
1139
1140 /*
1141 * Count of SCSI adapters
1142 */
1143 int
1144 scsi_get_adapter_count(void)
1145 {
1146 /* Currently support one adapter only */
1147 return (1);
1148 }
1149
1150 /*
1151 * Return the SCSI adapter structure
1152 */
1153 /*ARGSUSED*/
1154 scsi_adapter_t *
1155 scsi_get_adapter(int adapter)
1156 {
1157 return (&my_sa);
1158 }
1159
1160 /*
1161 * IOCTL wrapper with retries
1162 */
1163 int
1164 tlm_ioctl(int fd, int cmd, void *data)
1165 {
1166 int retries = 0;
1167
1168 NDMP_LOG(LOG_DEBUG, "tlm_ioctl fd %d cmd %d", fd, cmd);
1169 if (fd == 0 || data == NULL)
1170 return (EINVAL);
1171
1172 do {
1173 if (ioctl(fd, cmd, data) == 0)
1174 break;
1175
1176 if (errno != EIO && errno != 0) {
1177 NDMP_LOG(LOG_ERR,
1178 "Failed to send command to device: %m.");
1179 NDMP_LOG(LOG_DEBUG, "IOCTL error %d", errno);
1180 return (errno);
1181 }
1182 (void) sleep(1);
1183 } while (retries++ < MAXIORETRY);
1184
1185 return (0);
1186 }
1187
1188 /*
1189 * Checkpoint or snapshot calls
1190 */
1191
1192 /*
1193 * Get the snapshot creation time
1194 */
1195 int
1196 chkpnt_creationtime_bypattern(char *volname, char *pattern, time_t *tp)
1197 {
1198 char chk_name[PATH_MAX];
1199 zfs_handle_t *zhp;
1200 char *p;
1201
1202 if (!volname || !*volname)
1203 return (-1);
1204
1205 /* Should also return -1 if checkpoint not enabled */
1206
1207 /* Remove the leading slash */
1208 p = volname;
1209 while (*p == '/')
1210 p++;
1211
1212 (void) strlcpy(chk_name, p, PATH_MAX);
1213 (void) strlcat(chk_name, "@", PATH_MAX);
1214 (void) strlcat(chk_name, pattern, PATH_MAX);
1215
1216 (void) mutex_lock(&zlib_mtx);
1217 if ((zhp = zfs_open(zlibh, chk_name, ZFS_TYPE_DATASET)) == NULL) {
1218 NDMP_LOG(LOG_DEBUG, "chkpnt_creationtime: open %s failed",
1219 chk_name);
1220 (void) mutex_unlock(&zlib_mtx);
1221 return (-1);
1222 }
1223
1224 *tp = zfs_prop_get_int(zhp, ZFS_PROP_CREATION);
1225 zfs_close(zhp);
1226 (void) mutex_unlock(&zlib_mtx);
1227
1228 return (0);
1229 }
1230
1231
1232 /*
1233 * Get the ZFS volume name out of the given path
1234 */
1235 int
1236 get_zfsvolname(char *volname, int len, char *path)
1237 {
1238 struct stat64 stbuf;
1239 struct extmnttab ent;
1240 FILE *mntfp;
1241 int rv;
1242
1243 *volname = '\0';
1244 if (stat64(path, &stbuf) != 0) {
1245 return (-1);
1246 }
1247
1248 if ((mntfp = fopen(MNTTAB, "r")) == NULL) {
1249 return (-1);
1250 }
1251 while ((rv = getextmntent(mntfp, &ent, 0)) == 0) {
1252 if (makedevice(ent.mnt_major, ent.mnt_minor) ==
1253 stbuf.st_dev)
1254 break;
1255 }
1256
1257 if (rv == 0 &&
1258 strcmp(ent.mnt_fstype, MNTTYPE_ZFS) == 0)
1259 (void) strlcpy(volname, ent.mnt_special, len);
1260 else
1261 rv = -1;
1262
1263 (void) fclose(mntfp);
1264 return (rv);
1265 }
1266
1267
1268 /*
1269 * Check if the volume type is snapshot volume
1270 */
1271 boolean_t
1272 fs_is_chkpntvol(char *path)
1273 {
1274 zfs_handle_t *zhp;
1275 char vol[ZFS_MAX_DATASET_NAME_LEN];
1276
1277 if (!path || !*path)
1278 return (FALSE);
1279
1280 if (get_zfsvolname(vol, sizeof (vol), path) == -1)
1281 return (FALSE);
1282
1283 (void) mutex_lock(&zlib_mtx);
1284 if ((zhp = zfs_open(zlibh, vol, ZFS_TYPE_DATASET)) == NULL) {
1285 (void) mutex_unlock(&zlib_mtx);
1286 return (FALSE);
1287 }
1288
1289 if (zfs_get_type(zhp) != ZFS_TYPE_SNAPSHOT) {
1290 zfs_close(zhp);
1291 (void) mutex_unlock(&zlib_mtx);
1292 return (FALSE);
1293 }
1294 zfs_close(zhp);
1295 (void) mutex_unlock(&zlib_mtx);
1296
1297 return (TRUE);
1298 }
1299
1300 /*
1301 * Check if the volume is capable of checkpoints
1302 */
1303 boolean_t
1304 fs_is_chkpnt_enabled(char *path)
1305 {
1306 zfs_handle_t *zhp;
1307 char vol[ZFS_MAX_DATASET_NAME_LEN];
1308
1309 if (!path || !*path)
1310 return (FALSE);
1311
1312 (void) mutex_lock(&zlib_mtx);
1313 if (get_zfsvolname(vol, sizeof (vol), path) == -1) {
1314 (void) mutex_unlock(&zlib_mtx);
1315 return (FALSE);
1316 }
1317
1318 if ((zhp = zfs_open(zlibh, vol, ZFS_TYPE_DATASET)) == NULL) {
1319 (void) mutex_unlock(&zlib_mtx);
1320 return (FALSE);
1321 }
1322 zfs_close(zhp);
1323 (void) mutex_unlock(&zlib_mtx);
1324
1325 return (TRUE);
1326 }
1327
1328 /*
1329 * Check if the volume is read-only
1330 */
1331 boolean_t
1332 fs_is_rdonly(char *path)
1333 {
1334 return (fs_is_chkpntvol(path));
1335 }
1336
1337 /*
1338 * Min/max functions
1339 */
1340 unsigned
1341 min(unsigned a, unsigned b)
1342 {
1343 return (a < b ? a : b);
1344 }
1345
1346 unsigned
1347 max(unsigned a, unsigned b)
1348 {
1349 return (a > b ? a : b);
1350 }
1351
1352 longlong_t
1353 llmin(longlong_t a, longlong_t b)
1354 {
1355 return (a < b ? a : b);
1356 }