tlm_lib.c revision 5181c2afafac4c39b4d5d9d8dd14e6ba0d227db2
/*
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
*/
/*
* BSD 3 Clause License
*
* Copyright (c) 2007, The Storage Networking Industry Association.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* - Neither the name of The Storage Networking Industry Association (SNIA)
* nor the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/errno.h>
#include <ctype.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>
#include <libzfs.h>
#include <pthread.h>
#include "tlm.h"
#include "tlm_proto.h"
#include <sys/mtio.h>
#include <sys/mnttab.h>
#include <sys/mntent.h>
#include <sys/statvfs.h>
#include <sys/scsi/impl/uscsi.h>
#include <sys/scsi/scsi.h>
#include <sys/mtio.h>
#include <thread.h>
#include <synch.h>
#include <sys/mutex.h>
#include <sys/sysmacros.h>
#include <sys/mkdev.h>
/*
* Tar archiving ops vector
*/
tm_ops_t tm_tar_ops = {
"tar",
tar_putfile,
tar_putdir,
NULL,
tar_getfile,
tar_getdir,
NULL
};
extern libzfs_handle_t *zlibh;
extern mutex_t zlib_mtx;
/*
* get the next tape buffer from the drive's pool of buffers
*/
/*ARGSUSED*/
char *
tlm_get_write_buffer(long want, long *actual_size,
tlm_buffers_t *buffers, int zero)
{
int buf = buffers->tbs_buffer_in;
tlm_buffer_t *buffer = &buffers->tbs_buffer[buf];
int align_size = RECORDSIZE - 1;
char *rec;
/*
* make sure the allocation is in chunks of 512 bytes
*/
want += align_size;
want &= ~align_size;
*actual_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
if (*actual_size <= 0) {
/*
* no room, send this one
* and wait for a free one
*/
if (!buffer->tb_full) {
/*
* we are now ready to send a full buffer
* instead of trying to get a new buffer
*
* do not send if we failed to get a buffer
* on the previous call
*/
buffer->tb_full = TRUE;
/*
* tell the writer that a buffer is available
*/
tlm_buffer_release_in_buf(buffers);
buffer = tlm_buffer_advance_in_idx(buffers);
}
buffer = tlm_buffer_in_buf(buffers, NULL);
if (buffer->tb_full) {
/*
* wait for the writer to free up a buffer
*/
tlm_buffer_out_buf_timed_wait(buffers, 500);
}
buffer = tlm_buffer_in_buf(buffers, NULL);
if (buffer->tb_full) {
/*
* the next buffer is still full
* of data from previous activity
*
* nothing has changed.
*/
return (0);
}
buffer->tb_buffer_spot = 0;
*actual_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
}
*actual_size = min(want, *actual_size);
rec = &buffer->tb_buffer_data[buffer->tb_buffer_spot];
buffer->tb_buffer_spot += *actual_size;
buffers->tbs_offset += *actual_size;
if (zero) {
(void) memset(rec, 0, *actual_size);
}
return (rec);
}
/*
* get a read record from the tape buffer,
* and read a tape block if necessary
*/
/*ARGSUSED*/
char *
tlm_get_read_buffer(int want, int *error,
tlm_buffers_t *buffers, int *actual_size)
{
tlm_buffer_t *buffer;
int align_size = RECORDSIZE - 1;
int buf;
int current_size;
char *rec;
buf = buffers->tbs_buffer_out;
buffer = &buffers->tbs_buffer[buf];
/*
* make sure the allocation is in chunks of 512 bytes
*/
want += align_size;
want &= ~align_size;
current_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
if (buffer->tb_full && current_size <= 0) {
/*
* no more data, release this
* one and go get another
*/
/*
* tell the reader that a buffer is available
*/
buffer->tb_full = FALSE;
tlm_buffer_release_out_buf(buffers);
buffer = tlm_buffer_advance_out_idx(buffers);
current_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
}
if (!buffer->tb_full) {
/*
* next buffer is not full yet.
* wait for the reader.
*/
tlm_buffer_in_buf_timed_wait(buffers, 500);
buffer = tlm_buffer_out_buf(buffers, NULL);
if (!buffer->tb_full) {
/*
* we do not have anything from the tape yet
*/
return (0);
}
current_size = buffer->tb_buffer_size - buffer->tb_buffer_spot;
}
/* Make sure we got something */
if (current_size <= 0)
return (NULL);
current_size = min(want, current_size);
rec = &buffer->tb_buffer_data[buffer->tb_buffer_spot];
buffer->tb_buffer_spot += current_size;
*actual_size = current_size;
/*
* the error flag is only sent back one time,
* since the flag refers to a previous read
* attempt, not the data in this buffer.
*/
*error = buffer->tb_errno;
return (rec);
}
/*
* unread a previously read buffer back to the tape buffer
*/
void
tlm_unget_read_buffer(tlm_buffers_t *buffers, int size)
{
tlm_buffer_t *buffer;
int align_size = RECORDSIZE - 1;
int buf;
int current_size;
buf = buffers->tbs_buffer_out;
buffer = &buffers->tbs_buffer[buf];
/*
* make sure the allocation is in chunks of 512 bytes
*/
size += align_size;
size &= ~align_size;
current_size = min(size, buffer->tb_buffer_spot);
buffer->tb_buffer_spot -= current_size;
}
/*
* unwrite a previously written buffer
*/
void
tlm_unget_write_buffer(tlm_buffers_t *buffers, int size)
{
tlm_buffer_t *buffer;
int align_size = RECORDSIZE - 1;
int buf;
int current_size;
buf = buffers->tbs_buffer_in;
buffer = &buffers->tbs_buffer[buf];
/*
* make sure the allocation is in chunks of 512 bytes
*/
size += align_size;
size &= ~align_size;
current_size = min(size, buffer->tb_buffer_spot);
buffer->tb_buffer_spot -= current_size;
}
/*
* build a checksum for a TAR header record
*/
void
tlm_build_header_checksum(tlm_tar_hdr_t *r)
{
int i;
int sum = 0;
char *c = (char *)r;
(void) memcpy(r->th_chksum, CHKBLANKS, strlen(CHKBLANKS));
for (i = 0; i < RECORDSIZE; i++) {
sum += c[i] & 0xFF;
}
(void) snprintf(r->th_chksum, sizeof (r->th_chksum), "%6o", sum);
}
/*
* verify the tar header checksum
*/
int
tlm_vfy_tar_checksum(tlm_tar_hdr_t *tar_hdr)
{
int chksum = oct_atoi(tar_hdr->th_chksum);
uchar_t *p = (uchar_t *)tar_hdr;
int sum = 0; /* initial value of checksum */
int i; /* loop counter */
/*
* compute the checksum
*/
for (i = 0; i < RECORDSIZE; i++) {
sum += p[i] & 0xFF;
}
if (sum == 0) {
NDMP_LOG(LOG_DEBUG,
"should be %d, is 0", chksum);
/* a zero record ==> end of tar file */
return (0);
}
/*
* subtract out the label's checksum values
* this lets us undo the old checksum "in-
* place", no need to swap blanks in and out
*/
for (i = 0; i < 8; i++) {
sum -= 0xFF & tar_hdr->th_chksum[i];
}
/*
* replace the old checksum field with blanks
*/
sum += ' ' * 8;
if (sum != chksum)
NDMP_LOG(LOG_DEBUG,
"should be %d, is %d", chksum, sum);
return ((sum == chksum) ? 1 : -1);
}
/*
* get internal scsi_sasd entry for this tape drive
*/
int
tlm_get_scsi_sasd_entry(int lib, int drv)
{
int entry;
int i, n;
scsi_link_t *sl;
tlm_drive_t *dp;
entry = -1;
dp = tlm_drive(lib, drv);
if (!dp) {
NDMP_LOG(LOG_DEBUG, "NULL dp for (%d.%d)", lib, drv);
} else if (!dp->td_slink) {
NDMP_LOG(LOG_DEBUG, "NULL dp->td_slink for (%d.%d)", lib, drv);
} else if (!dp->td_slink->sl_sa) {
NDMP_LOG(LOG_DEBUG, "NULL dp->td_slink->sl_sa for (%d.%d)",
lib, drv);
} else {
/* search through the SASD table */
n = sasd_dev_count();
for (i = 0; i < n; i++) {
sl = sasd_dev_slink(i);
if (!sl)
continue;
if (dp->td_slink->sl_sa == sl->sl_sa &&
dp->td_scsi_id == sl->sl_sid &&
dp->td_lun == sl->sl_lun) {
/* all 3 variables match */
entry = i;
break;
}
}
}
return (entry);
}
/*
* get the OS device name for this tape
*/
char *
tlm_get_tape_name(int lib, int drv)
{
int entry;
entry = tlm_get_scsi_sasd_entry(lib, drv);
if (entry >= 0) {
sasd_drive_t *sd;
if ((sd = sasd_drive(entry)) != 0)
return (sd->sd_name);
}
return ("");
}
/*
* create the IPC area between the reader and writer
*/
tlm_cmd_t *
tlm_create_reader_writer_ipc(boolean_t write, long data_transfer_size)
{
tlm_cmd_t *cmd;
cmd = ndmp_malloc(sizeof (tlm_cmd_t));
if (cmd == NULL)
return (NULL);
cmd->tc_reader = TLM_BACKUP_RUN;
cmd->tc_writer = TLM_BACKUP_RUN;
cmd->tc_ref = 1;
cmd->tc_buffers = tlm_allocate_buffers(write, data_transfer_size);
if (cmd->tc_buffers == NULL) {
free(cmd);
return (NULL);
}
(void) mutex_init(&cmd->tc_mtx, 0, NULL);
(void) cond_init(&cmd->tc_cv, 0, NULL);
return (cmd);
}
/*
* release(destroy) the IPC between the reader and writer
*/
void
tlm_release_reader_writer_ipc(tlm_cmd_t *cmd)
{
if (--cmd->tc_ref <= 0) {
(void) mutex_lock(&cmd->tc_mtx);
tlm_release_buffers(cmd->tc_buffers);
(void) cond_destroy(&cmd->tc_cv);
(void) mutex_unlock(&cmd->tc_mtx);
(void) mutex_destroy(&cmd->tc_mtx);
free(cmd);
}
}
/*
* NDMP support begins here.
*/
/*
* Initialize the file history callback functions
*/
lbr_fhlog_call_backs_t *
lbrlog_callbacks_init(void *cookie, path_hist_func_t log_pname_func,
dir_hist_func_t log_dir_func, node_hist_func_t log_node_func)
{
lbr_fhlog_call_backs_t *p;
p = ndmp_malloc(sizeof (lbr_fhlog_call_backs_t));
if (p == NULL)
return (NULL);
p->fh_cookie = cookie;
p->fh_logpname = (func_t)log_pname_func;
p->fh_log_dir = (func_t)log_dir_func;
p->fh_log_node = (func_t)log_node_func;
return (p);
}
/*
* Cleanup the callbacks
*/
void
lbrlog_callbacks_done(lbr_fhlog_call_backs_t *p)
{
if (p != NULL)
(void) free((char *)p);
}
/*
* Call back for file history directory info
*/
int
tlm_log_fhdir(tlm_job_stats_t *job_stats, char *dir, struct stat64 *stp,
fs_fhandle_t *fhp)
{
int rv;
lbr_fhlog_call_backs_t *cbp; /* callbacks pointer */
rv = 0;
if (job_stats == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhdir: jstat is NULL");
} else if (dir == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhdir: dir is NULL");
} else if (stp == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhdir: stp is NULL");
} else if ((cbp = (lbr_fhlog_call_backs_t *)job_stats->js_callbacks)
== NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhdir: cbp is NULL");
} else if (cbp->fh_log_dir == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhdir: callback is NULL");
} else
rv = (*cbp->fh_log_dir)(cbp, dir, stp, fhp);
return (rv);
}
/*
* Call back for file history node info
*/
int
tlm_log_fhnode(tlm_job_stats_t *job_stats, char *dir, char *file,
struct stat64 *stp, u_longlong_t off)
{
int rv;
lbr_fhlog_call_backs_t *cbp; /* callbacks pointer */
rv = 0;
if (job_stats == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhnode: jstat is NULL");
} else if (dir == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhnode: dir is NULL");
} else if (file == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhnode: file is NULL");
} else if (stp == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhnode: stp is NULL");
} else if ((cbp = (lbr_fhlog_call_backs_t *)job_stats->js_callbacks)
== NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhnode: cbp is NULL");
} else if (cbp->fh_log_node == NULL) {
NDMP_LOG(LOG_DEBUG, "log_fhnode: callback is NULL");
} else
rv = (*cbp->fh_log_node)(cbp, dir, file, stp, off);
return (rv);
}
/*
* Call back for file history path info
*/
int
tlm_log_fhpath_name(tlm_job_stats_t *job_stats, char *pathname,
struct stat64 *stp, u_longlong_t off)
{
int rv;
lbr_fhlog_call_backs_t *cbp; /* callbacks pointer */
rv = 0;
if (!job_stats) {
NDMP_LOG(LOG_DEBUG, "log_fhpath_name: jstat is NULL");
} else if (!pathname) {
NDMP_LOG(LOG_DEBUG, "log_fhpath_name: pathname is NULL");
} else if (!stp) {
NDMP_LOG(LOG_DEBUG, "log_fhpath_name: stp is NULL");
} else if ((cbp = (lbr_fhlog_call_backs_t *)job_stats->js_callbacks)
== 0) {
NDMP_LOG(LOG_DEBUG, "log_fhpath_name: cbp is NULL");
} else if (!cbp->fh_logpname) {
NDMP_LOG(LOG_DEBUG, "log_fhpath_name: callback is NULL");
} else
rv = (*cbp->fh_logpname)(cbp, pathname, stp, off);
return (rv);
}
/*
* Log call back to report the entry recovery
*/
int
tlm_entry_restored(tlm_job_stats_t *job_stats, char *name, int pos)
{
lbr_fhlog_call_backs_t *cbp; /* callbacks pointer */
NDMP_LOG(LOG_DEBUG, "name: \"%s\", pos: %d", name, pos);
if (job_stats == NULL) {
NDMP_LOG(LOG_DEBUG, "entry_restored: jstat is NULL");
return (0);
}
cbp = (lbr_fhlog_call_backs_t *)job_stats->js_callbacks;
if (cbp == NULL) {
NDMP_LOG(LOG_DEBUG, "entry_restored is NULL");
return (0);
}
return (*cbp->fh_logpname)(cbp, name, 0, (longlong_t)pos);
}
/*
* NDMP support ends here.
*/
/*
* Function: tlm_cat_path
* Concatenates two path names
* or directory name and file name
* into a buffer passed by the caller. A slash
* is inserted if required. Buffer is assumed
* to hold PATH_MAX characters.
*
* Parameters:
* char *buf - buffer to write new dir/name string
* char *dir - directory name
* char *name - file name
*
* Returns:
* TRUE - No errors. buf contains the dir/name string
* FALSE - Error. buf is not modified.
*/
boolean_t
tlm_cat_path(char *buf, char *dir, char *name)
{
char *fmt;
int dirlen = strlen(dir);
int filelen = strlen(name);
if ((dirlen + filelen + 1) >= PATH_MAX) {
return (FALSE);
}
if (*dir == '\0' || *name == '\0' || dir[dirlen - 1] == '/' ||
*name == '/') {
fmt = "%s%s";
} else {
fmt = "%s/%s";
}
/* check for ".../" and "/...." */
if ((dirlen > 0) && (dir[dirlen - 1] == '/') && (*name == '/'))
name += strspn(name, "/");
/* LINTED variable format */
(void) snprintf(buf, TLM_MAX_PATH_NAME, fmt, dir, name);
return (TRUE);
}
/*
* Get the checkpoint (snapshot) creation time.
* This is necessary to check for checkpoints not being stale.
*/
int
tlm_get_chkpnt_time(char *path, int auto_checkpoint, time_t *tp, char *jname)
{
char volname[TLM_VOLNAME_MAX_LENGTH];
char chk_name[PATH_MAX];
char *cp_nm;
NDMP_LOG(LOG_DEBUG, "path [%s] auto_checkpoint: %d",
path, auto_checkpoint);
if (path == NULL || *path == '\0' || tp == NULL)
return (-1);
if (get_zfsvolname(volname, TLM_VOLNAME_MAX_LENGTH,
path) == -1)
return (-1);
if (auto_checkpoint) {
NDMP_LOG(LOG_DEBUG, "volname [%s]", volname);
(void) snprintf(chk_name, PATH_MAX, "%s", jname);
return (chkpnt_creationtime_bypattern(volname, chk_name, tp));
}
cp_nm = strchr(volname, '@');
NDMP_LOG(LOG_DEBUG, "volname [%s] cp_nm [%s]", volname, cp_nm);
return (chkpnt_creationtime_bypattern(volname, cp_nm, tp));
}
/*
* Release an array of pointers and the pointers themselves.
*/
void
tlm_release_list(char **lpp)
{
char **save;
if ((save = lpp) == 0)
return;
while (*lpp)
free(*lpp++);
free(save);
}
/*
* Print the list of array of strings in the backup log
*/
void
tlm_log_list(char *title, char **lpp)
{
int i;
if (!lpp)
return;
NDMP_LOG(LOG_DEBUG, "%s:", title);
for (i = 0; *lpp; lpp++, i++)
NDMP_LOG(LOG_DEBUG, "%d: [%s]", i, *lpp);
}
/*
* Insert the backup snapshot name into the path.
*
* Input:
* name: Original path name.
*
* Output:
* name: Original name modified to include a snapshot.
*
* Returns:
* Original name modified to include a snapshot.
*/
char *
tlm_build_snapshot_name(char *name, char *sname, char *jname)
{
zfs_handle_t *zhp;
char *rest;
char volname[ZFS_MAXNAMELEN];
char mountpoint[PATH_MAX];
if (get_zfsvolname(volname, ZFS_MAXNAMELEN, name) == -1)
goto notzfs;
(void) mutex_lock(&zlib_mtx);
if ((zlibh == NULL) ||
(zhp = zfs_open(zlibh, volname, ZFS_TYPE_DATASET)) == NULL) {
(void) mutex_unlock(&zlib_mtx);
goto notzfs;
}
if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, PATH_MAX, NULL,
NULL, 0, B_FALSE) != 0) {
zfs_close(zhp);
(void) mutex_unlock(&zlib_mtx);
goto notzfs;
}
zfs_close(zhp);
(void) mutex_unlock(&zlib_mtx);
rest = name + strlen(mountpoint);
(void) snprintf(sname, TLM_MAX_PATH_NAME, "%s/%s/%s%s", mountpoint,
TLM_SNAPSHOT_DIR, jname, rest);
return (sname);
notzfs:
(void) strlcpy(sname, name, TLM_MAX_PATH_NAME);
return (sname);
}
/*
* Remove the checkpoint from a path name.
*
* Input:
* name: Full pathname with checkpoint embeded.
*
* Output:
* unchkp_name: real pathname with no checkpoint.
*
* Returns:
* Pointer to the un-checkpointed path.
*/
char *
tlm_remove_checkpoint(char *name, char *unchkp_name)
{
char *cp;
int i;
int plen;
unchkp_name[0] = name[0];
plen = strlen(TLM_SNAPSHOT_PREFIX);
for (i = 1; i <= TLM_VOLNAME_MAX_LENGTH + 1; i++) {
switch (name[i]) {
case '.':
if (strncmp(&name[i], TLM_SNAPSHOT_PREFIX,
plen) == 0) {
unchkp_name[i] = '\0';
i += plen;
if (name[i] == '\0') {
/*
* name == "/v1.chkpnt"
*/
return (unchkp_name);
}
if ((cp = strchr(&name[++i], '/')) != NULL) {
(void) strlcat(unchkp_name, cp,
TLM_VOLNAME_MAX_LENGTH + 1);
}
return (unchkp_name);
} else {
unchkp_name[i] = name[i];
}
break;
case '/':
return (name);
case 0:
return (name);
default:
unchkp_name[i] = name[i];
break;
}
}
return (name);
}
/*
* see if we should exclude this file.
*/
boolean_t
tlm_is_excluded(char *dir, char *name, char **excl_files)
{
int i;
char full_name[TLM_MAX_PATH_NAME];
if (!dir || !name || !excl_files)
return (FALSE);
if (!tlm_cat_path(full_name, dir, name)) {
NDMP_LOG(LOG_DEBUG, "Path too long [%s][%s]",
dir, name);
return (FALSE);
}
for (i = 0; excl_files[i] != 0; i++) {
if (match(excl_files[i], full_name)) {
return (TRUE);
}
}
return (FALSE);
}
/*
* Check if the path is too long
*/
boolean_t
tlm_is_too_long(int checkpointed, char *dir, char *nm)
{
int nlen, tot;
tot = 0;
if (dir)
tot += strlen(dir);
if (checkpointed)
tot += strlen(TLM_SNAPSHOT_DIR) + 1;
if (nm) {
if ((nlen = strlen(nm)) > 0)
tot += nlen + 1;
}
return ((tot >= PATH_MAX) ? TRUE : FALSE);
}
/*
* Get the data offset of inside the buffer
*/
longlong_t
tlm_get_data_offset(tlm_cmd_t *lcmds)
{
if (!lcmds)
return (0LL);
return (lcmds->tc_buffers->tbs_offset);
}
/*
* Enable the barcode capability on the library
*/
void
tlm_enable_barcode(int l)
{
tlm_library_t *lp;
if ((lp = tlm_library(l))) {
lp->tl_capability_barcodes = TRUE;
NDMP_LOG(LOG_DEBUG,
"Barcode capability on library %d enabled.", l);
}
}
/*
* SASD SCSI support
*/
static scsi_adapter_t my_sa;
static int sasd_drive_count = 0;
static scsi_sasd_drive_t *scsi_sasd_drives[128];
/*
* Count of SCSI devices
*/
int
sasd_dev_count(void)
{
return (sasd_drive_count);
}
/*
* Return the SCSI device name
*/
char *
sasd_slink_name(scsi_link_t *slink)
{
int i;
for (i = 0; i < sasd_drive_count; i++) {
if (&scsi_sasd_drives[i]->ss_slink == slink)
return (scsi_sasd_drives[i]->ss_sd.sd_name);
}
return (NULL);
}
/*
* Return the SCSI drive structure
*/
sasd_drive_t *
sasd_slink_drive(scsi_link_t *slink)
{
int i;
for (i = 0; i < sasd_drive_count; i++) {
if (&scsi_sasd_drives[i]->ss_slink == slink)
return (&scsi_sasd_drives[i]->ss_sd);
}
return (NULL);
}
/*
* Return the SCSI link pointer for the given index
*/
scsi_link_t *
sasd_dev_slink(int entry)
{
scsi_link_t *rv;
if (entry >= 0 && entry < sasd_drive_count)
rv = &scsi_sasd_drives[entry]->ss_slink;
else
rv = NULL;
return (rv);
}
/*
* Return the SCSI drive for the given index
*/
sasd_drive_t *
sasd_drive(int entry)
{
sasd_drive_t *rv;
if (entry >= 0 && entry < sasd_drive_count)
rv = &scsi_sasd_drives[entry]->ss_sd;
else
rv = NULL;
return (rv);
}
/*
* Attach the SCSI device by updating the structures
*/
void
scsi_sasd_attach(scsi_adapter_t *sa, int sid, int lun, char *name,
int type)
{
scsi_link_t *sl, *next;
scsi_sasd_drive_t *ssd;
ssd = ndmp_malloc(sizeof (scsi_sasd_drive_t));
if (ssd == NULL)
return;
scsi_sasd_drives[sasd_drive_count++] = ssd;
switch (type) {
case DTYPE_CHANGER:
(void) snprintf(ssd->ss_sd.sd_name,
sizeof (ssd->ss_sd.sd_name), "%s/%s", SCSI_CHANGER_DIR,
name);
break;
case DTYPE_SEQUENTIAL:
(void) snprintf(ssd->ss_sd.sd_name,
sizeof (ssd->ss_sd.sd_name), "%s/%s", SCSI_TAPE_DIR, name);
break;
}
sl = &ssd->ss_slink;
sl->sl_type = type;
sl->sl_sa = sa;
sl->sl_lun = lun;
sl->sl_sid = sid;
sl->sl_requested_max_active = 1;
/* Insert slink */
next = sa->sa_link_head.sl_next;
sa->sa_link_head.sl_next = sl;
sl->sl_next = next;
}
/*
* Go through the attached devices and detect the tape
* and robot by checking the /dev entries
*/
int
probe_scsi(void)
{
DIR *dirp;
struct dirent *dp;
scsi_adapter_t *sa = &my_sa;
char *p;
int lun = 0;
int sid = 0;
/* Initialize the scsi adapter link */
sa->sa_link_head.sl_next = &sa->sa_link_head;
/* Scan for the changer */
dirp = opendir(SCSI_CHANGER_DIR);
if (dirp == NULL) {
NDMP_LOG(LOG_DEBUG,
"Changer directory read error %s", SCSI_CHANGER_DIR);
} else {
while ((dp = readdir(dirp)) != NULL) {
if ((strcmp(dp->d_name, ".") == 0) ||
(strcmp(dp->d_name, "..") == 0))
continue;
if ((p = strchr(dp->d_name, 'd')) != NULL) {
lun = atoi(++p);
p = strchr(dp->d_name, 't');
sid = atoi(++p);
}
else
sid = atoi(dp->d_name);
scsi_sasd_attach(sa, 0, lun, dp->d_name,
DTYPE_CHANGER);
}
(void) closedir(dirp);
}
/* Scan for tape drives */
dirp = opendir(SCSI_TAPE_DIR);
if (dirp == NULL) {
NDMP_LOG(LOG_DEBUG,
"Tape directory read error %s", SCSI_TAPE_DIR);
} else {
while ((dp = readdir(dirp)) != NULL) {
if ((strcmp(dp->d_name, ".") == 0) ||
(strcmp(dp->d_name, "..") == 0))
continue;
/* Skip special modes */
if (strpbrk(dp->d_name, "bchlmu") != 0)
continue;
/* Pick the non-rewind device */
if (strchr(dp->d_name, 'n') == NULL)
continue;
sid = atoi(dp->d_name);
/*
* SCSI ID should match with the ID of the device
* (will be checked by SCSI get elements page later)
*/
scsi_sasd_attach(sa, sid, 0, dp->d_name,
DTYPE_SEQUENTIAL);
}
(void) closedir(dirp);
}
return (0);
}
/*
* Get the SCSI device type (tape, robot)
*/
/*ARGSUSED*/
int
scsi_get_devtype(char *adapter, int sid, int lun)
{
int rv;
scsi_adapter_t *sa = &my_sa;
scsi_link_t *sl, *sh;
rv = -1;
sh = &sa->sa_link_head;
for (sl = sh->sl_next; sl != sh; sl = sl->sl_next)
if (sl->sl_sid == sid && sl->sl_lun == lun)
rv = sl->sl_type;
return (rv);
}
/*
* Check if the SCSI device exists
*/
/*ARGSUSED*/
int
scsi_dev_exists(char *adapter, int sid, int lun)
{
scsi_adapter_t *sa = &my_sa;
scsi_link_t *sl, *sh;
sh = &sa->sa_link_head;
for (sl = sh->sl_next; sl != sh; sl = sl->sl_next)
if (sl->sl_sid == sid && sl->sl_lun == lun)
return (1);
return (0);
}
/*
* Count of SCSI adapters
*/
int
scsi_get_adapter_count(void)
{
/* Currently support one adapter only */
return (1);
}
/*
* Return the SCSI adapter structure
*/
/*ARGSUSED*/
scsi_adapter_t *
scsi_get_adapter(int adapter)
{
return (&my_sa);
}
/*
* IOCTL wrapper with retries
*/
int
tlm_ioctl(int fd, int cmd, void *data)
{
int retries = 0;
NDMP_LOG(LOG_DEBUG, "tlm_ioctl fd %d cmd %d", fd, cmd);
if (fd == 0 || data == NULL)
return (EINVAL);
do {
if (ioctl(fd, cmd, data) == 0)
break;
if (errno != EIO && errno != 0) {
NDMP_LOG(LOG_ERR,
"Failed to send command to device: %m.");
NDMP_LOG(LOG_DEBUG, "IOCTL error %d", errno);
return (errno);
}
(void) sleep(1);
} while (retries++ < MAXIORETRY);
return (0);
}
/*
* Checkpoint or snapshot calls
*/
/*
* Create a snapshot on the volume
*/
int
chkpnt_backup_prepare(char *volname, char *jname, boolean_t recursive)
{
char chk_name[PATH_MAX];
char *p;
int rv;
if (!volname || !*volname)
return (-1);
/* Should also return -1 if checkpoint not enabled */
/* Remove the leading slash */
p = volname;
while (*p == '/')
p++;
(void) snprintf(chk_name, PATH_MAX, "%s@%s", p, jname);
(void) mutex_lock(&zlib_mtx);
if ((rv = zfs_snapshot(zlibh, chk_name, recursive, NULL))
== -1) {
if (errno == EEXIST) {
(void) mutex_unlock(&zlib_mtx);
return (0);
}
NDMP_LOG(LOG_DEBUG,
"chkpnt_backup_prepare: %s failed (err=%d): %s",
chk_name, errno, libzfs_error_description(zlibh));
(void) mutex_unlock(&zlib_mtx);
return (rv);
}
(void) mutex_unlock(&zlib_mtx);
return (0);
}
/*
* Remove the 'backup' snapshot if backup was successful
*/
int
chkpnt_backup_successful(char *volname, char *jname, boolean_t recursive,
int *zfs_err)
{
char chk_name[PATH_MAX];
zfs_handle_t *zhp;
zfs_type_t ztype;
int err;
char *p;
if (zfs_err)
*zfs_err = 0;
if (!volname || !*volname)
return (-1);
/* Should also return -1 if checkpoint not enabled */
/* Remove the leading slash */
p = volname;
while (*p == '/')
p++;
if (recursive) {
ztype = ZFS_TYPE_VOLUME | ZFS_TYPE_FILESYSTEM;
} else {
(void) snprintf(chk_name, PATH_MAX, "%s@%s", p, jname);
p = chk_name;
ztype = ZFS_TYPE_SNAPSHOT;
}
(void) mutex_lock(&zlib_mtx);
if ((zhp = zfs_open(zlibh, p, ztype)) == NULL) {
NDMP_LOG(LOG_DEBUG, "chkpnt_backup_successful: open %s failed",
p);
(void) mutex_unlock(&zlib_mtx);
return (-1);
}
if (recursive) {
err = zfs_destroy_snaps(zhp, jname, B_TRUE);
} else {
err = zfs_destroy(zhp, B_TRUE);
}
if (err) {
NDMP_LOG(LOG_ERR, "%s (recursive destroy: %d): %d; %s; %s",
p,
recursive,
libzfs_errno(zlibh),
libzfs_error_action(zlibh),
libzfs_error_description(zlibh));
if (zfs_err)
*zfs_err = err;
}
zfs_close(zhp);
(void) mutex_unlock(&zlib_mtx);
return (0);
}
/*
* Get the snapshot creation time
*/
int
chkpnt_creationtime_bypattern(char *volname, char *pattern, time_t *tp)
{
char chk_name[PATH_MAX];
zfs_handle_t *zhp;
char *p;
if (!volname || !*volname)
return (-1);
/* Should also return -1 if checkpoint not enabled */
/* Remove the leading slash */
p = volname;
while (*p == '/')
p++;
(void) strlcpy(chk_name, p, PATH_MAX);
(void) strlcat(chk_name, "@", PATH_MAX);
(void) strlcat(chk_name, pattern, PATH_MAX);
(void) mutex_lock(&zlib_mtx);
if ((zhp = zfs_open(zlibh, chk_name, ZFS_TYPE_DATASET)) == NULL) {
NDMP_LOG(LOG_DEBUG, "chkpnt_creationtime: open %s failed",
chk_name);
(void) mutex_unlock(&zlib_mtx);
return (-1);
}
*tp = zfs_prop_get_int(zhp, ZFS_PROP_CREATION);
zfs_close(zhp);
(void) mutex_unlock(&zlib_mtx);
return (0);
}
/*
* Get the ZFS volume name out of the given path
*/
int
get_zfsvolname(char *volname, int len, char *path)
{
struct stat64 stbuf;
struct extmnttab ent;
FILE *mntfp;
int rv;
*volname = '\0';
if (stat64(path, &stbuf) != 0) {
return (-1);
}
if ((mntfp = fopen(MNTTAB, "r")) == NULL) {
return (-1);
}
while ((rv = getextmntent(mntfp, &ent, 0)) == 0) {
if (makedevice(ent.mnt_major, ent.mnt_minor) ==
stbuf.st_dev)
break;
}
if (rv == 0 &&
strcmp(ent.mnt_fstype, MNTTYPE_ZFS) == 0)
(void) strlcpy(volname, ent.mnt_special, len);
else
rv = -1;
(void) fclose(mntfp);
return (rv);
}
/*
* Check if the volume type is snapshot volume
*/
boolean_t
fs_is_chkpntvol(char *path)
{
zfs_handle_t *zhp;
char vol[ZFS_MAXNAMELEN];
if (!path || !*path)
return (FALSE);
if (get_zfsvolname(vol, sizeof (vol), path) == -1)
return (FALSE);
(void) mutex_lock(&zlib_mtx);
if ((zhp = zfs_open(zlibh, vol, ZFS_TYPE_DATASET)) == NULL) {
(void) mutex_unlock(&zlib_mtx);
return (FALSE);
}
if (zfs_get_type(zhp) != ZFS_TYPE_SNAPSHOT) {
zfs_close(zhp);
(void) mutex_unlock(&zlib_mtx);
return (FALSE);
}
zfs_close(zhp);
(void) mutex_unlock(&zlib_mtx);
return (TRUE);
}
/*
* Check if the volume is capable of checkpoints
*/
boolean_t
fs_is_chkpnt_enabled(char *path)
{
zfs_handle_t *zhp;
char vol[ZFS_MAXNAMELEN];
if (!path || !*path)
return (FALSE);
(void) mutex_lock(&zlib_mtx);
if (get_zfsvolname(vol, sizeof (vol), path) == -1) {
(void) mutex_unlock(&zlib_mtx);
return (FALSE);
}
if ((zhp = zfs_open(zlibh, vol, ZFS_TYPE_DATASET)) == NULL) {
(void) mutex_unlock(&zlib_mtx);
return (FALSE);
}
zfs_close(zhp);
(void) mutex_unlock(&zlib_mtx);
return (TRUE);
}
/*
* Check if the volume is read-only
*/
boolean_t
fs_is_rdonly(char *path)
{
return (fs_is_chkpntvol(path));
}
/*
* Min/max functions
*/
unsigned
min(a, b)
unsigned a, b;
{
return (a < b ? a : b);
}
unsigned
max(a, b)
unsigned a, b;
{
return (a > b ? a : b);
}
longlong_t
llmin(longlong_t a, longlong_t b)
{
return (a < b ? a : b);
}