/* If there is no default ACL get standard ACL */
myAcl = acl_get_file(ff_pkt->fname, ACL_TYPE_ACCESS);
if (!myAcl) {
- Emsg1(M_WARNING, 0, "Error while trying to get ACL of directory: %s!\n", ff_pkt->fname);
+ Jmsg1(jcr, M_WARNING, 0, "Error while trying to get ACL of directory: %s!\n", ff_pkt->fname);
}
}
acl_text = acl_to_any_text(myAcl, NULL, ',', TEXT_ABBREVIATE);
/* Files or links */
acl_t myAcl = acl_get_file(ff_pkt->fname, ACL_TYPE_ACCESS);
if (!myAcl) {
- Emsg1(M_WARNING, 0, "Error while trying to get ACL of file: %s!\n", ff_pkt->fname);
+ Jmsg1(jcr, M_WARNING, 0, "Error while trying to get ACL of file: %s!\n", ff_pkt->fname);
acl_free(myAcl);
}
acl_text = acl_to_any_text(myAcl, NULL, ',', TEXT_ABBREVIATE);
sd->msglen = 0;
bclose(&ff_pkt->bfd);
set_jcr_job_status(jcr, JS_ErrorTerminated);
- Emsg1(M_WARNING, 0, "Error while trying to send ACL of %s to SD!\n", ff_pkt->fname);
+ Jmsg1(jcr, M_FATAL, 0, "Error while trying to send ACL of %s to SD!\n", ff_pkt->fname);
} else {
jcr->JobBytes += sd->msglen;
sd->msg = msgsave;
/* Recover ACL from stream and check it */
acl = acl_from_text(sd->msg);
if (acl_valid(acl) != 0) {
- Emsg1(M_WARNING, 0, "Failure in the ACL of %s! FD is not able to restore it!\n", jcr->last_fname);
+ Jmsg1(jcr, M_WARNING, 0, "Failure in the ACL of %s! FD is not able to restore it!\n", jcr->last_fname);
acl_free(acl);
}
/* Directory */
if (acl_set_file(jcr->last_fname, ACL_TYPE_DEFAULT, acl) != 0 &&
acl_set_file(jcr->last_fname, ACL_TYPE_ACCESS, acl) != 0) {
- Emsg1(M_WARNING, 0, "Error! Can't restore ACL of directory: %s! Maybe system does not support ACLs!\n", jcr->last_fname);
+ Jmsg1(jcr, M_WARNING, 0, "Error! Can't restore ACL of directory: %s! Maybe system does not support ACLs!\n", jcr->last_fname);
}
/* File or Link */
} else if (acl_set_file(jcr->last_fname, ACL_TYPE_ACCESS, acl) != 0) {
- Emsg1(M_WARNING, 0, "Error! Can't restore ACL of file: %s! Maybe system does not support ACLs!\n", jcr->last_fname);
+ Jmsg1(jcr, M_WARNING, 0, "Error! Can't restore ACL of file: %s! Maybe system does not support ACLs!\n", jcr->last_fname);
}
acl_free(acl);
Dmsg1(200, "ACL of file: %s successfully restored!", jcr->last_fname);
dcr->rec = new_record();
dcr->spool_fd = -1;
dcr->max_spool_size = dev->device->max_spool_size;
+// dev->attached_dcrs->append(dcr);
return dcr;
}
void free_dcr(DCR *dcr)
{
+// dcr->dev->attached_dcrs->remove(dcr);
if (dcr->block) {
free_block(dcr->block);
}
default_path:
tape_previously_mounted = true;
Dmsg0(200, "dir_get_volume_info\n");
- if (!dir_get_volume_info(jcr, GET_VOL_INFO_FOR_READ)) {
+ if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_READ)) {
Jmsg1(jcr, M_WARNING, 0, "%s", jcr->errmsg);
}
/* Call autochanger only once unless ask_sysop called */
int stat;
Dmsg2(200, "calling autoload Vol=%s Slot=%d\n",
jcr->VolumeName, jcr->VolCatInfo.Slot);
- stat = autoload_device(jcr, dev, 0, NULL);
+ stat = autoload_device(dcr, 0, NULL);
if (stat > 0) {
try_autochanger = false;
continue;
}
/* Mount a specific volume and no other */
Dmsg0(200, "calling dir_ask_sysop\n");
- if (!dir_ask_sysop_to_mount_volume(jcr)) {
+ if (!dir_ask_sysop_to_mount_volume(dcr)) {
goto get_out; /* error return */
}
try_autochanger = true; /* permit using autochanger again */
*/
pm_strcpy(&jcr->VolumeName, dev->VolHdr.VolName);
bstrncpy(dcr->VolumeName, dev->VolHdr.VolName, sizeof(dcr->VolumeName));
- if (!dir_get_volume_info(jcr, GET_VOL_INFO_FOR_WRITE) &&
- !(dir_find_next_appendable_volume(jcr) &&
+ if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE) &&
+ !(dir_find_next_appendable_volume(dcr) &&
strcmp(dev->VolHdr.VolName, jcr->VolumeName) == 0)) { /* wrong tape mounted */
if (dev->num_writers != 0) {
DEVICE *d = ((DEVRES *)dev->device)->dev;
*/
bool release_device(JCR *jcr)
{
- DEVICE *dev = jcr->dcr->dev;
+ DCR *dcr = jcr->dcr;
+ DEVICE *dev = dcr->dev;
lock_device(dev);
Dmsg1(100, "release_device device is %s\n", dev_is_tape(dev)?"tape":"disk");
if (dev_state(dev, ST_READ)) {
Dmsg1(100, "There are %d writers in release_device\n", dev->num_writers);
if (dev_state(dev, ST_LABEL)) {
Dmsg0(100, "dir_create_jobmedia_record. Release\n");
- if (!dir_create_jobmedia_record(jcr)) {
+ if (!dir_create_jobmedia_record(dcr)) {
Jmsg(jcr, M_ERROR, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
jcr->VolCatInfo.VolCatName, jcr->Job);
}
dev->VolCatInfo.VolCatJobs++; /* increment number of jobs */
/* Note! do volume update before close, which zaps VolCatInfo */
Dmsg0(100, "dir_update_vol_info. Release0\n");
- dir_update_volume_info(jcr, false); /* send Volume info to Director */
+ dir_update_volume_info(dcr, false); /* send Volume info to Director */
}
if (!dev->num_writers && (!dev_is_tape(dev) || !dev_cap(dev, CAP_ALWAYSOPEN))) {
jcr->dir_bsock->spool = true;
}
Dmsg0(200, "Send attributes.\n");
- if (!dir_update_file_attributes(jcr, &rec)) {
+ if (!dir_update_file_attributes(dcr, &rec)) {
jcr->dir_bsock->spool = false;
Jmsg(jcr, M_FATAL, 0, _("Error updating file attributes. ERR=%s\n"),
bnet_strerror(jcr->dir_bsock));
static char OK_create[] = "1000 OK CreateJobMedia\n";
/* Forward referenced functions */
-static int wait_for_sysop(JCR *jcr, DEVICE *dev);
+static int wait_for_sysop(DCR *dcr);
/*
* Send current JobStatus to Director
* Returns: true on success and vol info in jcr->VolCatInfo
* false on failure
*/
-static bool do_get_volume_info(JCR *jcr)
+static bool do_get_volume_info(DCR *dcr)
{
+ JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
- DCR *dcr = jcr->dcr;
VOLUME_CAT_INFO vol;
int n;
int InChanger;
*
* Volume information returned in jcr
*/
-bool dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing)
+bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
{
+ JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
bstrncpy(jcr->VolCatInfo.VolCatName, jcr->VolumeName, sizeof(jcr->VolCatInfo.VolCatName));
bash_spaces(jcr->VolCatInfo.VolCatName);
bnet_fsend(dir, Get_Vol_Info, jcr->Job, jcr->VolCatInfo.VolCatName,
writing==GET_VOL_INFO_FOR_WRITE?1:0);
- return do_get_volume_info(jcr);
+ return do_get_volume_info(dcr);
}
* Volume information returned in jcr
*
*/
-bool dir_find_next_appendable_volume(JCR *jcr)
+bool dir_find_next_appendable_volume(DCR *dcr)
{
+ JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
JCR *njcr;
Dmsg0(200, "dir_find_next_appendable_volume\n");
for (int vol_index=1; vol_index < 3; vol_index++) {
bnet_fsend(dir, Find_media, jcr->Job, vol_index);
- if (do_get_volume_info(jcr)) {
+ if (do_get_volume_info(dcr)) {
Dmsg2(200, "JobId=%d got possible Vol=%s\n", jcr->JobId, jcr->VolumeName);
bool found = false;
/*
* back to the director. The information comes from the
* dev record.
*/
-bool dir_update_volume_info(JCR *jcr, bool label)
+bool dir_update_volume_info(DCR *dcr, bool label)
{
+ JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
- DEVICE *dev = jcr->dcr->dev;
+ DEVICE *dev = dcr->dev;
time_t LastWritten = time(NULL);
char ed1[50], ed2[50], ed3[50], ed4[50];
VOLUME_CAT_INFO *vol = &dev->VolCatInfo;
Dmsg1(120, "update_volume_info(): %s", dir->msg);
unbash_spaces(vol->VolCatName);
- if (!do_get_volume_info(jcr)) {
+ if (!do_get_volume_info(dcr)) {
Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg);
return false;
}
/*
* After writing a Volume, create the JobMedia record.
*/
-bool dir_create_jobmedia_record(JCR *jcr)
+bool dir_create_jobmedia_record(DCR *dcr)
{
+ JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
- DCR *dcr = jcr->dcr;
if (!dcr->WroteVol) {
return true; /* nothing written to tape */
/*
* Update File Attribute data
*/
-bool dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec)
+bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec)
{
+ JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
ser_declare;
* actually be mounted. The calling routine must read it and
* verify the label.
*/
-bool dir_ask_sysop_to_create_appendable_volume(JCR *jcr)
+bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
{
int stat = 0, jstat;
bool unmounted;
bool first = true;
- DEVICE *dev = jcr->dcr->dev;
+ DEVICE *dev = dcr->dev;
+ JCR *jcr = dcr->jcr;
Dmsg0(130, "enter dir_ask_sysop_to_create_appendable_volume\n");
ASSERT(dev->dev_blocked);
return false;
}
/* First pass, we *know* there are no appendable volumes, so no need to call */
- if (!first && dir_find_next_appendable_volume(jcr)) { /* get suggested volume */
+ if (!first && dir_find_next_appendable_volume(dcr)) { /* get suggested volume */
unmounted = (dev->dev_blocked == BST_UNMOUNTED) ||
(dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
/*
jcr->JobStatus = jstat;
dir_send_job_status(jcr);
- stat = wait_for_sysop(jcr, dev);
+ stat = wait_for_sysop(dcr);
if (dev->poll) {
Dmsg1(200, "Poll timeout in create append vol on device %s\n", dev_name(dev));
continue;
/* If no VolumeName, and cannot get one, try again */
if (jcr->VolumeName[0] == 0 && !job_canceled(jcr) &&
- !dir_find_next_appendable_volume(jcr)) {
+ !dir_find_next_appendable_volume(dcr)) {
Jmsg(jcr, M_MOUNT, 0, _(
"Someone woke me up, but I cannot find any appendable\n\
volumes for Job=%s.\n"), jcr->Job);
* Note, must create dev->errmsg on error return.
*
*/
-bool dir_ask_sysop_to_mount_volume(JCR *jcr)
+bool dir_ask_sysop_to_mount_volume(DCR *dcr)
{
int stat = 0;
const char *msg;
- DEVICE *dev = jcr->dcr->dev;
+ DEVICE *dev = dcr->dev;
+ JCR *jcr = dcr->jcr;
Dmsg0(130, "enter dir_ask_sysop_to_mount_volume\n");
if (!jcr->VolumeName[0]) {
jcr->JobStatus = JS_WaitMount;
dir_send_job_status(jcr);
- stat = wait_for_sysop(jcr, dev); /* wait on device */
+ stat = wait_for_sysop(dcr); ; /* wait on device */
if (dev->poll) {
Dmsg1(200, "Poll timeout in mount vol on device %s\n", dev_name(dev));
Dmsg1(200, "Blocked=%d\n", dev->dev_blocked);
/*
* Wait for SysOp to mount a tape
*/
-static int wait_for_sysop(JCR *jcr, DEVICE *dev)
+static int wait_for_sysop(DCR *dcr)
{
struct timeval tv;
struct timezone tz;
int stat = 0;
int add_wait;
bool unmounted;
+ DEVICE *dev = dcr->dev;
+ JCR *jcr = dcr->jcr;
P(dev->mutex);
unmounted = (dev->dev_blocked == BST_UNMOUNTED) ||
* 0 on failure (no changer available)
* -1 on error on autochanger
*/
-int autoload_device(JCR *jcr, DEVICE *dev, int writing, BSOCK *dir)
+int autoload_device(DCR *dcr, int writing, BSOCK *dir)
{
+ JCR *jcr = dcr->jcr;
+ DEVICE *dev = dcr->dev;
int slot = jcr->VolCatInfo.Slot;
int drive = jcr->device->drive_index;
int rtn_stat = -1; /* error status */
if (dir) {
return 0; /* For user, bail out right now */
}
- if (dir_find_next_appendable_volume(jcr)) {
+ if (dir_find_next_appendable_volume(dcr)) {
slot = jcr->VolCatInfo.Slot;
} else {
slot = 0;
* The Volume is not in the correct slot, so mark this
* Volume as not being in the Changer.
*/
-void invalid_slot_in_catalog(JCR *jcr, DEVICE *dev)
+void invalid_slot_in_catalog(DCR *dcr)
{
+ JCR *jcr = dcr->jcr;
+ DEVICE *dev = dcr->dev;
Jmsg(jcr, M_ERROR, 0, _("Autochanger Volume \"%s\" not found in slot %d.\n"
" Setting slot to zero in catalog.\n"),
jcr->VolCatInfo.VolCatName, jcr->VolCatInfo.Slot);
jcr->VolCatInfo.InChanger = false;
dev->VolCatInfo.InChanger = false;
Dmsg0(100, "update vol info in mount\n");
- dir_update_volume_info(jcr, true); /* set new status */
+ dir_update_volume_info(dcr, true); /* set new status */
}
/*
* with their barcodes.
* We assume that it is always the Console that is calling us.
*/
-int autochanger_list(JCR *jcr, DEVICE *dev, BSOCK *dir)
+bool autochanger_list(DCR *dcr, BSOCK *dir)
{
+ DEVICE *dev = dcr->dev;
+ JCR *jcr = dcr->jcr;
uint32_t timeout = jcr->device->max_changer_wait;
POOLMEM *changer;
BPIPE *bpipe;
if (!dev_cap(dev, CAP_AUTOCHANGER) || !jcr->device->changer_name ||
!jcr->device->changer_command) {
bnet_fsend(dir, _("3993 Not a autochanger device.\n"));
- return 0;
+ return false;
}
changer = get_pool_memory(PM_FNAME);
bpipe = open_bpipe(changer, timeout, "r");
if (!bpipe) {
bnet_fsend(dir, _("3993 Open bpipe failed.\n"));
- goto bail_out;
+ free_pool_memory(changer);
+ return false;
}
/* Get output from changer */
while (fgets(dir->msg, len, bpipe->rfd)) {
bnet_sig(dir, BNET_EOD);
close_bpipe(bpipe);
-bail_out:
free_pool_memory(changer);
- return 1;
+ return true;
}
-
/*
* Edit codes into ChangerCommand
* %% = %
/* Dummies to replace askdir.c */
-bool dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing) { return 1;}
-bool dir_find_next_appendable_volume(JCR *jcr) { return 1;}
-bool dir_update_volume_info(JCR *jcr, bool relabel) { return 1; }
-bool dir_create_jobmedia_record(JCR *jcr) { return 1; }
-bool dir_ask_sysop_to_create_appendable_volume(JCR *jcr) { return 1; }
-bool dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
+bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing) { return 1;}
+bool dir_find_next_appendable_volume(DCR *dcr) { return 1;}
+bool dir_update_volume_info(DCR *dcr, bool relabel) { return 1; }
+bool dir_create_jobmedia_record(DCR *dcr) { return 1; }
+bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr) { return 1; }
+bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
bool dir_send_job_status(JCR *jcr) {return 1;}
-bool dir_ask_sysop_to_mount_volume(JCR *jcr)
+bool dir_ask_sysop_to_mount_volume(DCR *dcr)
{
- DEVICE *dev = jcr->dcr->dev;
+ JCR *jcr = dcr->jcr;
+ DEVICE *dev = dcr->dev;
fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
jcr->VolumeName, dev_name(dev));
getchar();
}
/* Dummies to replace askdir.c */
-bool dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing) { return 1;}
-bool dir_find_next_appendable_volume(JCR *jcr) { return 1;}
-bool dir_update_volume_info(JCR *jcr, bool relabel) { return 1; }
-bool dir_create_jobmedia_record(JCR *jcr) { return 1; }
-bool dir_ask_sysop_to_create_appendable_volume(JCR *jcr) { return 1; }
-bool dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
+bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing) { return 1;}
+bool dir_find_next_appendable_volume(DCR *dcr) { return 1;}
+bool dir_update_volume_info(DCR *dcr, bool relabel) { return 1; }
+bool dir_create_jobmedia_record(DCR *dcr) { return 1; }
+bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr) { return 1; }
+bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
bool dir_send_job_status(JCR *jcr) {return 1;}
-bool dir_ask_sysop_to_mount_volume(JCR *jcr)
+bool dir_ask_sysop_to_mount_volume(DCR *dcr)
{
- DEVICE *dev = jcr->dcr->dev;
+ JCR *jcr = dcr->jcr;
+ DEVICE *dev = dcr->dev;
fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
jcr->VolumeName, dev_name(dev));
getchar();
*/
if (dcr->NewVol || dcr->NewFile) {
/* Create a jobmedia record for this job */
- if (!dir_create_jobmedia_record(jcr)) {
+ if (!dir_create_jobmedia_record(dcr)) {
dev->dev_errno = EIO;
Jmsg(jcr, M_ERROR, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
jcr->VolCatInfo.VolCatName, jcr->Job);
- set_new_volume_parameters(jcr, dev);
+ set_new_volume_parameters(dcr);
stat = false;
goto bail_out;
}
if (dcr->NewVol) {
/* Note, setting a new volume also handles any pending new file */
- set_new_volume_parameters(jcr, dev);
+ set_new_volume_parameters(dcr);
dcr->NewFile = false; /* this handled for new file too */
} else {
- set_new_file_parameters(jcr, dev);
+ set_new_file_parameters(dcr);
}
}
/* Don't do update after second EOF or file count will be wrong */
Dmsg0(100, "dir_update_volume_info\n");
dev->VolCatInfo.VolCatFiles = dev->file;
- dir_update_volume_info(jcr, false);
+ dir_update_volume_info(dcr, false);
if (dev_cap(dev, CAP_TWOEOF) && weof_dev(dev, 1) != 0) { /* write eof */
Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
dev->VolCatInfo.VolCatErrors++;
dev->state |= (ST_EOF | ST_EOT | ST_WEOT);
Dmsg0(100, "dir_update_volume_info\n");
dev->VolCatInfo.VolCatFiles = dev->file;
- dir_update_volume_info(jcr, false);
+ dir_update_volume_info(dcr, false);
dev->dev_errno = ENOSPC;
return false;
}
/* Create a JobMedia record so restore can seek */
Dmsg0(100, "dir_update_volume_info\n");
dev->VolCatInfo.VolCatFiles = dev->file;
- dir_update_volume_info(jcr, false);
- if (!dir_create_jobmedia_record(jcr)) {
+ dir_update_volume_info(dcr, false);
+ if (!dir_create_jobmedia_record(dcr)) {
dev->dev_errno = EIO;
Jmsg(jcr, M_ERROR, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
dcr->VolCatInfo.VolCatName, jcr->Job);
}
mjcr->dcr->NewFile = true; /* set reminder to do set_new_file_params */
}
- set_new_file_parameters(jcr, dev);
+ set_new_file_parameters(dcr);
}
dev->VolCatInfo.VolCatWrites++;
}
Dmsg0(100, "dir_update_volume_info\n");
dev->VolCatInfo.VolCatFiles = dev->file;
- dir_update_volume_info(jcr, false);
+ dir_update_volume_info(dcr, false);
if (dev_cap(dev, CAP_TWOEOF) && weof_dev(dev, 1) != 0) { /* end the tape */
dev->VolCatInfo.VolCatErrors++;
Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
/* Dummies to replace askdir.c */
-bool dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing) { return 1;}
-bool dir_find_next_appendable_volume(JCR *jcr) { return 1;}
-bool dir_update_volume_info(JCR *jcr, bool relabel) { return 1; }
-bool dir_create_jobmedia_record(JCR *jcr) { return 1; }
-bool dir_ask_sysop_to_create_appendable_volume(JCR *jcr) { return 1; }
-bool dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
+bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing) { return 1;}
+bool dir_find_next_appendable_volume(DCR *dcr) { return 1;}
+bool dir_update_volume_info(DCR *dcr, bool relabel) { return 1; }
+bool dir_create_jobmedia_record(DCR *dcr) { return 1; }
+bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr) { return 1; }
+bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
bool dir_send_job_status(JCR *jcr) {return 1;}
-bool dir_ask_sysop_to_mount_volume(JCR *jcr)
+bool dir_ask_sysop_to_mount_volume(DCR *dcr)
{
- DEVICE *dev = jcr->dcr->dev;
+ JCR *jcr = dcr->jcr;
+ DEVICE *dev = dcr->dev;
fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
jcr->VolumeName, dev_name(dev));
getchar();
}
/* Dummies to replace askdir.c */
-bool dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing) { return 1;}
-bool dir_find_next_appendable_volume(JCR *jcr) { return 1;}
-bool dir_update_volume_info(JCR *jcr, bool relabel) { return 1; }
-bool dir_create_jobmedia_record(JCR *jcr) { return 1; }
-bool dir_ask_sysop_to_create_appendable_volume(JCR *jcr) { return 1; }
-bool dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
+bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing) { return 1;}
+bool dir_find_next_appendable_volume(DCR *dcr) { return 1;}
+bool dir_update_volume_info(DCR *dcr, bool relabel) { return 1; }
+bool dir_create_jobmedia_record(DCR *dcr) { return 1; }
+bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr) { return 1; }
+bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
bool dir_send_job_status(JCR *jcr) {return 1;}
-bool dir_ask_sysop_to_mount_volume(JCR *jcr)
+bool dir_ask_sysop_to_mount_volume(DCR *dcr)
{
- DEVICE *dev = jcr->dcr->dev;
+ DEVICE *dev = dcr->dev;
+ JCR *jcr = dcr->jcr;
fprintf(stderr, _("Mount Volume \"%s\" on device \"%s\" and press return when ready: "),
jcr->VolumeName, dev_name(dev));
getchar();
if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
offline_dev(dev);
}
- autochanger = autoload_device(jcr, dev, 1, NULL);
+ autochanger = autoload_device(dcr, 1, NULL);
if (!autochanger) {
force_close_dev(dev);
get_cmd(_("Mount first tape. Press enter when ready: "));
set_volume_name("TestVolume2", 2);
jcr->bsr = NULL;
create_vol_list(jcr);
- autochanger = autoload_device(jcr, dev, 1, NULL);
+ autochanger = autoload_device(dcr, 1, NULL);
if (!autochanger) {
force_close_dev(dev);
get_cmd(_("Mount second tape. Press enter when ready: "));
}
/* Dummies to replace askdir.c */
-bool dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
+bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
bool dir_send_job_status(JCR *jcr) {return 1;}
-bool dir_update_volume_info(JCR *jcr, bool relabel)
+bool dir_update_volume_info(DCR *dcr, bool relabel)
{
return 1;
}
-bool dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing)
+bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
{
+ JCR *jcr = dcr->jcr;
Dmsg0(20, "Enter dir_get_volume_info\n");
bstrncpy(jcr->VolCatInfo.VolCatName, jcr->VolumeName, sizeof(jcr->VolCatInfo.VolCatName));
return 1;
}
-bool dir_create_jobmedia_record(JCR *jcr)
+bool dir_create_jobmedia_record(DCR *dcr)
{
- jcr->dcr->WroteVol = false;
+ dcr->WroteVol = false;
return 1;
}
-bool dir_find_next_appendable_volume(JCR *jcr)
+bool dir_find_next_appendable_volume(DCR *dcr)
{
+ JCR *jcr = dcr->jcr;
Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
return jcr->VolumeName[0] != 0;
}
-bool dir_ask_sysop_to_mount_volume(JCR *jcr)
+bool dir_ask_sysop_to_mount_volume(DCR *dcr)
{
- DEVICE *dev = jcr->dcr->dev;
+ DEVICE *dev = dcr->dev;
+ JCR *jcr = dcr->jcr;
Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
if (jcr->VolumeName[0] == 0) {
- return dir_ask_sysop_to_create_appendable_volume(jcr);
+ return dir_ask_sysop_to_create_appendable_volume(dcr);
}
/* Close device so user can use autochanger if desired */
if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
return true;
}
-bool dir_ask_sysop_to_create_appendable_volume(JCR *jcr)
+bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
{
bool autochanger;
- DEVICE *dev = jcr->dcr->dev;
+ DEVICE *dev = dcr->dev;
+ JCR *jcr = dcr->jcr;
Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
if (stop == 0) {
set_volume_name("TestVolume1", 1);
if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
offline_dev(dev);
}
- autochanger = autoload_device(jcr, dev, 1, NULL);
+ autochanger = autoload_device(dcr, 1, NULL);
if (!autochanger) {
force_close_dev(dev);
fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
Mmsg1(&dev->errmsg, _("Unable to init mutex: ERR=%s\n"), strerror(errstat));
Emsg0(M_FATAL, 0, dev->errmsg);
}
+#ifdef xxx
+ if ((errstat = rwl_init(&dev->lock)) != 0) {
+ dev->dev_errno = errstat;
+ Mmsg1(&dev->errmsg, _("Unable to init mutex: ERR=%s\n"), strerror(errstat));
+ Emsg0(M_FATAL, 0, dev->errmsg);
+ }
+#endif
+
dev->fd = -1;
dev->attached_dcrs = new dlist(dcr, &dcr->dev_link);
Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev_is_tape(dev), dev->dev_name);
int dev_prev_blocked; /* previous blocked state */
int num_waiting; /* number of threads waiting */
int num_writers; /* number of writing threads */
+
+ /* New access control in process of being implemented */
+ brwlock_t lock; /* New mutual exclusion lock */
+
int use_count; /* usage count on this device */
int fd; /* file descriptor */
int capabilities; /* capabilities mask */
unlock_device(dev);
/* Create a jobmedia record for this job */
- if (!dir_create_jobmedia_record(jcr)) {
+ if (!dir_create_jobmedia_record(dcr)) {
Jmsg(jcr, M_ERROR, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
jcr->VolCatInfo.VolCatName, jcr->Job);
P(dev->mutex);
dev->VolCatInfo.VolCatStatus, dev->VolCatInfo.VolCatName);
dev->VolCatInfo.VolCatFiles = dev->file; /* set number of files */
dev->VolCatInfo.VolCatJobs++; /* increment number of jobs */
- if (!dir_update_volume_info(jcr, false)) { /* send Volume info to Director */
+ if (!dir_update_volume_info(dcr, false)) { /* send Volume info to Director */
P(dev->mutex);
unblock_device(dev);
return false; /* device locked */
/* Clear NewVol now because dir_get_volume_info() already done */
jcr->dcr->NewVol = false;
- set_new_volume_parameters(jcr, dev);
+ set_new_volume_parameters(dcr);
jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
* concerning this job. The global changes were made earlier
* in the dev structure.
*/
-void set_new_volume_parameters(JCR *jcr, DEVICE *dev)
+void set_new_volume_parameters(DCR *dcr)
{
- DCR *dcr = jcr->dcr;
- if (dcr->NewVol && !dir_get_volume_info(jcr, GET_VOL_INFO_FOR_WRITE)) {
+ JCR *jcr = dcr->jcr;
+ DEVICE *dev = dcr->dev;
+ if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
}
/* Set new start/end positions */
* concerning this job. The global changes were made earlier
* in the dev structure.
*/
-void set_new_file_parameters(JCR *jcr, DEVICE *dev)
+void set_new_file_parameters(DCR *dcr)
{
- DCR *dcr = jcr->dcr;
+ DEVICE *dev = dcr->dev;
/* Set new start/end positions */
if (dev_state(dev, ST_TAPE)) {
return 1;
}
+void dev_lock(DEVICE *dev)
+{
+ int errstat;
+ if ((errstat=rwl_writelock(&dev->lock))) {
+ Emsg1(M_ABORT, 0, "Device write lock failure. ERR=%s\n", strerror(errstat));
+ }
+}
+
+void dev_unlock(DEVICE *dev)
+{
+ int errstat;
+ if ((errstat=rwl_writeunlock(&dev->lock))) {
+ Emsg1(M_ABORT, 0, "Device write unlock failure. ERR=%s\n", strerror(errstat));
+ }
+}
+
/*
* When dev_blocked is set, all threads EXCEPT thread with id no_wait_id
* must wait. The no_wait_id thread is out obtaining a new volume
BSOCK *dir = jcr->dir_bsock;
DEV_BLOCK *block;
bsteal_lock_t hold;
+ DCR *dcr = jcr->dcr;
steal_device_lock(dev, &hold, BST_WRITING_LABEL);
block = new_block(dev);
pm_strcpy(&jcr->VolumeName, newname);
jcr->VolCatInfo.Slot = slot;
- if (autoload_device(jcr, dev, 0, dir) < 0) { /* autoload if possible */
+ if (autoload_device(dcr, 0, dir) < 0) { /* autoload if possible */
goto bail_out;
}
}
/* See what we have for a Volume */
- switch (read_dev_volume_label(jcr->dcr, block)) {
+ switch (read_dev_volume_label(dcr, block)) {
case VOL_NAME_ERROR:
case VOL_VERSION_ERROR:
case VOL_LABEL_ERROR:
/* Fall through wanted! */
case VOL_IO_ERROR:
case VOL_NO_LABEL:
- if (!write_new_volume_label_to_dev(jcr->dcr, newname, poolname)) {
+ if (!write_new_volume_label_to_dev(dcr, newname, poolname)) {
bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), strerror_dev(dev));
break;
}
BSOCK *dir = jcr->dir_bsock;
DEV_BLOCK *block;
bsteal_lock_t hold;
+ DCR *dcr = jcr->dcr;
steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
jcr->VolumeName[0] = 0;
block = new_block(dev);
dev->state &= ~ST_LABEL; /* force read of label */
- switch (read_dev_volume_label(jcr->dcr, block)) {
+ switch (read_dev_volume_label(dcr, block)) {
case VOL_OK:
bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolName);
stat = 1;
POOLMEM *dname;
BSOCK *dir = jcr->dir_bsock;
DEVICE *dev;
+ DCR *dcr;
dname = get_memory(dir->msglen+1);
if (sscanf(dir->msg, "mount %s", dname) == 1) {
dev = find_device(jcr, dname);
+ dcr = jcr->dcr;
if (dev) {
DEV_BLOCK *block;
P(dev->mutex); /* Use P to avoid indefinite block */
break;
}
block = new_block(dev);
- read_dev_volume_label(jcr->dcr, block);
+ read_dev_volume_label(dcr, block);
free_block(block);
if (dev->dev_blocked == BST_UNMOUNTED) {
/* We blocked the device, so unblock it */
POOLMEM *dname;
BSOCK *dir = jcr->dir_bsock;
DEVICE *dev;
+ DCR *dcr;
dname = get_memory(dir->msglen+1);
if (sscanf(dir->msg, "autochanger list %s ", dname) == 1) {
dev = find_device(jcr, dname);
+ dcr = jcr->dcr;
if (dev) {
P(dev->mutex); /* Use P to avoid indefinite block */
if (!dev_is_tape(dev)) {
bnet_fsend(dir, _("3995 Device %s is not an autochanger.\n"), dev_name(dev));
} else if (!(dev->state & ST_OPENED)) {
- autochanger_list(jcr, dev, dir);
+ autochanger_list(dcr, dir);
/* Under certain "safe" conditions, we can steal the lock */
} else if (dev->dev_blocked &&
(dev->dev_blocked == BST_UNMOUNTED ||
dev->dev_blocked == BST_WAITING_FOR_SYSOP ||
dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP)) {
- autochanger_list(jcr, dev, dir);
+ autochanger_list(dcr, dir);
} else if (dev_state(dev, ST_READ) || dev->num_writers) {
if (dev_state(dev, ST_READ)) {
bnet_fsend(dir, _("3901 Device %s is busy with 1 reader.\n"), dev_name(dev));
dev_name(dev), dev->num_writers);
}
} else { /* device not being used */
- autochanger_list(jcr, dev, dir);
+ autochanger_list(dcr, dir);
}
V(dev->mutex);
} else {
BSOCK *dir = jcr->dir_bsock;
DEV_BLOCK *block;
bsteal_lock_t hold;
+ DCR *dcr = jcr->dcr;
steal_device_lock(dev, &hold, BST_WRITING_LABEL);
block = new_block(dev);
jcr->VolumeName[0] = 0;
jcr->VolCatInfo.Slot = Slot;
- if (autoload_device(jcr, dev, 0, dir) < 0) { /* autoload if possible */
+ if (autoload_device(dcr, 0, dir) < 0) { /* autoload if possible */
goto bail_out;
}
}
dev->state &= ~ST_LABEL; /* force read of label */
- switch (read_dev_volume_label(jcr->dcr, block)) {
+ switch (read_dev_volume_label(dcr, block)) {
case VOL_OK:
/* DO NOT add quotes around the Volume name. It is scanned in the DIR */
bnet_fsend(dir, _("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolName, Slot);
if (!dev->poll && retry++ > 4) {
/* Last ditch effort before giving up, force operator to respond */
jcr->VolCatInfo.Slot = 0;
- if (!dir_ask_sysop_to_mount_volume(jcr)) {
+ if (!dir_ask_sysop_to_mount_volume(dcr)) {
Jmsg(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s.\n"),
dev_name(dev));
return false;
* in jcr->VolCatInfo
*/
Dmsg0(200, "Before dir_find_next_appendable_volume.\n");
- while (!dir_find_next_appendable_volume(jcr)) {
+ while (!dir_find_next_appendable_volume(dcr)) {
Dmsg0(200, "not dir_find_next\n");
- if (!dir_ask_sysop_to_create_appendable_volume(jcr)) {
+ if (!dir_ask_sysop_to_create_appendable_volume(dcr)) {
return false;
}
Dmsg0(200, "Again dir_find_next_append...\n");
*/
dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
- if (autoload_device(jcr, dev, 1, NULL) > 0) {
+ if (autoload_device(dcr, 1, NULL) > 0) {
autochanger = true;
ask = false;
} else {
Dmsg2(100, "Ask=%d autochanger=%d\n", ask, autochanger);
release = true; /* release next time if we "recurse" */
- if (ask && !dir_ask_sysop_to_mount_volume(jcr)) {
+ if (ask && !dir_ask_sysop_to_mount_volume(dcr)) {
Dmsg0(100, "Error return ask_sysop ...\n");
return false; /* error return */
}
memcpy(&VolCatInfo, &jcr->VolCatInfo, sizeof(VolCatInfo));
/* Check if this is a valid Volume in the pool */
pm_strcpy(&jcr->VolumeName, dev->VolHdr.VolName);
- if (!dir_get_volume_info(jcr, GET_VOL_INFO_FOR_WRITE)) {
+ if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
bstrncpy(dev->BadVolName, dev->VolHdr.VolName, sizeof(dev->BadVolName));
Jmsg(jcr, M_WARNING, 0, _("Director wanted Volume \"%s\".\n"
" Current Volume \"%s\" not acceptable because:\n"
Dmsg0(100, "dir_update_vol_info. Set Append\n");
/* Copy Director's info into the device info */
memcpy(&dev->VolCatInfo, &jcr->VolCatInfo, sizeof(dev->VolCatInfo));
- dir_update_volume_info(jcr, true); /* indicate tape labeled */
+ dir_update_volume_info(dcr, true); /* indicate tape labeled */
Jmsg(jcr, M_INFO, 0, _("Labeled new Volume \"%s\" on device %s.\n"),
jcr->VolumeName, dev_name(dev));
goto read_volume; /* read label we just wrote */
}
dev->VolCatInfo.VolCatMounts++; /* Update mounts */
Dmsg1(100, "update volinfo mounts=%d\n", dev->VolCatInfo.VolCatMounts);
- dir_update_volume_info(jcr, false);
+ dir_update_volume_info(dcr, false);
/* Return an empty block */
empty_block(block); /* we used it for reading so set for write */
}
}
Dmsg0(100, "dir_update_vol_info. Set Append\n");
bstrncpy(dev->VolCatInfo.VolCatStatus, "Append", sizeof(dev->VolCatInfo.VolCatStatus));
- dir_update_volume_info(jcr, true); /* indicate doing relabel */
+ dir_update_volume_info(dcr, true); /* indicate doing relabel */
if (recycle) {
Jmsg(jcr, M_INFO, 0, _("Recycled volume \"%s\" on device \"%s\", all previous data lost.\n"),
jcr->VolumeName, dev_name(dev));
jcr->VolumeName);
bstrncpy(dev->VolCatInfo.VolCatStatus, "Error", sizeof(dev->VolCatInfo.VolCatStatus));
Dmsg0(100, "dir_update_vol_info. Set Error.\n");
- dir_update_volume_info(jcr, false);
+ dir_update_volume_info(jcr->dcr, false);
}
/*
uint32_t new_VolSessionId();
/* From acquire.c */
-DCR *acquire_device_for_append(JCR *jcr);
-DCR *acquire_device_for_read(JCR *jcr);
-bool release_device(JCR *jcr);
-DCR *new_dcr(JCR *jcr, DEVICE *dev);
-void free_dcr(DCR *dcr);
+DCR *acquire_device_for_append(JCR *jcr);
+DCR *acquire_device_for_read(JCR *jcr);
+bool release_device(JCR *jcr);
+DCR *new_dcr(JCR *jcr, DEVICE *dev);
+void free_dcr(DCR *dcr);
/* From askdir.c */
enum get_vol_info_rw {
GET_VOL_INFO_FOR_WRITE,
GET_VOL_INFO_FOR_READ
};
-bool dir_get_volume_info(JCR *jcr, enum get_vol_info_rw);
-bool dir_find_next_appendable_volume(JCR *jcr);
-bool dir_update_volume_info(JCR *jcr, bool label);
-bool dir_ask_sysop_to_create_appendable_volume(JCR *jcr);
-bool dir_ask_sysop_to_mount_volume(JCR *jcr);
-bool dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec);
-bool dir_send_job_status(JCR *jcr);
-bool dir_create_jobmedia_record(JCR *jcr);
+bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw);
+bool dir_find_next_appendable_volume(DCR *dcr);
+bool dir_update_volume_info(DCR *dcr, bool label);
+bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr);
+bool dir_ask_sysop_to_mount_volume(DCR *dcr);
+bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec);
+bool dir_send_job_status(JCR *jcr);
+bool dir_create_jobmedia_record(DCR *dcr);
/* authenticate.c */
-int authenticate_director(JCR *jcr);
-int authenticate_filed(JCR *jcr);
+int authenticate_director(JCR *jcr);
+int authenticate_filed(JCR *jcr);
/* From block.c */
-void dump_block(DEV_BLOCK *b, const char *msg);
+void dump_block(DEV_BLOCK *b, const char *msg);
DEV_BLOCK *new_block(DEVICE *dev);
DEV_BLOCK *dup_block(DEV_BLOCK *eblock);
-void init_block_write(DEV_BLOCK *block);
-void empty_block(DEV_BLOCK *block);
-void free_block(DEV_BLOCK *block);
-bool write_block_to_device(DCR *dcr, DEV_BLOCK *block);
-bool write_block_to_dev(DCR *dcr, DEV_BLOCK *block);
-void print_block_read_errors(JCR *jcr, DEV_BLOCK *block);
-void ser_block_header(DEV_BLOCK *block);
+void init_block_write(DEV_BLOCK *block);
+void empty_block(DEV_BLOCK *block);
+void free_block(DEV_BLOCK *block);
+bool write_block_to_device(DCR *dcr, DEV_BLOCK *block);
+bool write_block_to_dev(DCR *dcr, DEV_BLOCK *block);
+void print_block_read_errors(JCR *jcr, DEV_BLOCK *block);
+void ser_block_header(DEV_BLOCK *block);
#define CHECK_BLOCK_NUMBERS true
#define NO_BLOCK_NUMBER_CHECK false
-bool read_block_from_device(DCR *dcr, DEV_BLOCK *block, bool check_block_numbers);
-bool read_block_from_dev(DCR *dcr, DEV_BLOCK *block, bool check_block_numbers);
+bool read_block_from_device(DCR *dcr, DEV_BLOCK *block, bool check_block_numbers);
+bool read_block_from_dev(DCR *dcr, DEV_BLOCK *block, bool check_block_numbers);
/* From butil.c -- utilities for SD tool programs */
-void print_ls_output(const char *fname, const char *link, int type, struct stat *statp);
+void print_ls_output(const char *fname, const char *link, int type, struct stat *statp);
JCR *setup_jcr(const char *name, const char * device, BSR *bsr, const char *VolumeName);
DEVICE *setup_to_access_device(JCR *jcr, int read_access);
-void display_tape_error_status(JCR *jcr, DEVICE *dev);
+void display_tape_error_status(JCR *jcr, DEVICE *dev);
DEVRES *find_device_res(char *device_name, int read_access);
/* From dev.c */
-DEVICE *init_dev(DEVICE *dev, DEVRES *device);
-int open_dev(DEVICE *dev, char *VolName, int mode);
-void close_dev(DEVICE *dev);
-void force_close_dev(DEVICE *dev);
-int truncate_dev(DEVICE *dev);
-void term_dev(DEVICE *dev);
-char * strerror_dev(DEVICE *dev);
-void clrerror_dev(DEVICE *dev, int func);
-int update_pos_dev(DEVICE *dev);
-int rewind_dev(DEVICE *dev);
-int load_dev(DEVICE *dev);
-int offline_dev(DEVICE *dev);
-int flush_dev(DEVICE *dev);
-int weof_dev(DEVICE *dev, int num);
-int write_block(DEVICE *dev);
-int write_dev(DEVICE *dev, char *buf, size_t len);
-int read_dev(DEVICE *dev, char *buf, size_t len);
+DEVICE *init_dev(DEVICE *dev, DEVRES *device);
+int open_dev(DEVICE *dev, char *VolName, int mode);
+void close_dev(DEVICE *dev);
+void force_close_dev(DEVICE *dev);
+int truncate_dev(DEVICE *dev);
+void term_dev(DEVICE *dev);
+char * strerror_dev(DEVICE *dev);
+void clrerror_dev(DEVICE *dev, int func);
+int update_pos_dev(DEVICE *dev);
+int rewind_dev(DEVICE *dev);
+int load_dev(DEVICE *dev);
+int offline_dev(DEVICE *dev);
+int flush_dev(DEVICE *dev);
+int weof_dev(DEVICE *dev, int num);
+int write_block(DEVICE *dev);
+int write_dev(DEVICE *dev, char *buf, size_t len);
+int read_dev(DEVICE *dev, char *buf, size_t len);
uint32_t status_dev(DEVICE *dev);
-int eod_dev(DEVICE *dev);
-int fsf_dev(DEVICE *dev, int num);
-int fsr_dev(DEVICE *dev, int num);
-int bsf_dev(DEVICE *dev, int num);
-int bsr_dev(DEVICE *dev, int num);
-void attach_jcr_to_device(DEVICE *dev, JCR *jcr);
-void detach_jcr_from_device(DEVICE *dev, JCR *jcr);
-JCR *next_attached_jcr(DEVICE *dev, JCR *jcr);
-int dev_can_write(DEVICE *dev);
-int offline_or_rewind_dev(DEVICE *dev);
-int reposition_dev(DEVICE *dev, uint32_t file, uint32_t block);
-void init_dev_wait_timers(DEVICE *dev);
-bool double_dev_wait_time(DEVICE *dev);
+int eod_dev(DEVICE *dev);
+int fsf_dev(DEVICE *dev, int num);
+int fsr_dev(DEVICE *dev, int num);
+int bsf_dev(DEVICE *dev, int num);
+int bsr_dev(DEVICE *dev, int num);
+void attach_jcr_to_device(DEVICE *dev, JCR *jcr);
+void detach_jcr_from_device(DEVICE *dev, JCR *jcr);
+JCR *next_attached_jcr(DEVICE *dev, JCR *jcr);
+int dev_can_write(DEVICE *dev);
+int offline_or_rewind_dev(DEVICE *dev);
+int reposition_dev(DEVICE *dev, uint32_t file, uint32_t block);
+void init_dev_wait_timers(DEVICE *dev);
+bool double_dev_wait_time(DEVICE *dev);
/* Get info about device */
-char * dev_name(DEVICE *dev);
-char * dev_vol_name(DEVICE *dev);
+char * dev_name(DEVICE *dev);
+char * dev_vol_name(DEVICE *dev);
uint32_t dev_block(DEVICE *dev);
uint32_t dev_file(DEVICE *dev);
-int dev_is_tape(DEVICE *dev);
+int dev_is_tape(DEVICE *dev);
/* From device.c */
-int open_device(JCR *jcr, DEVICE *dev);
-int first_open_device(DEVICE *dev);
-bool fixup_device_block_write_error(DCR *dcr, DEV_BLOCK *block);
-void _lock_device(const char *file, int line, DEVICE *dev);
-void _unlock_device(const char *file, int line, DEVICE *dev);
-void _block_device(const char *file, int line, DEVICE *dev, int state);
-void _unblock_device(const char *file, int line, DEVICE *dev);
-void _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state);
-void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold);
-void set_new_volume_parameters(JCR *jcr, DEVICE *dev);
-void set_new_file_parameters(JCR *jcr, DEVICE *dev);
-int device_is_unmounted(DEVICE *dev);
+int open_device(JCR *jcr, DEVICE *dev);
+int first_open_device(DEVICE *dev);
+bool fixup_device_block_write_error(DCR *dcr, DEV_BLOCK *block);
+void _lock_device(const char *file, int line, DEVICE *dev);
+void _unlock_device(const char *file, int line, DEVICE *dev);
+void _block_device(const char *file, int line, DEVICE *dev, int state);
+void _unblock_device(const char *file, int line, DEVICE *dev);
+void _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state);
+void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold);
+void set_new_volume_parameters(DCR *dcr);
+void set_new_file_parameters(DCR *dcr);
+int device_is_unmounted(DEVICE *dev);
+void dev_lock(DEVICE *dev);
+void dev_unlock(DEVICE *dev);
/* From dircmd.c */
-void *handle_connection_request(void *arg);
+void *handle_connection_request(void *arg);
/* From fd_cmds.c */
-void run_job(JCR *jcr);
+void run_job(JCR *jcr);
/* From job.c */
-void stored_free_jcr(JCR *jcr);
-void connection_from_filed(void *arg);
-void handle_filed_connection(BSOCK *fd, char *job_name);
+void stored_free_jcr(JCR *jcr);
+void connection_from_filed(void *arg);
+void handle_filed_connection(BSOCK *fd, char *job_name);
/* From label.c */
-int read_dev_volume_label(DCR *dcr, DEV_BLOCK *block);
-void create_session_label(DCR *dcr, DEV_RECORD *rec, int label);
-void create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName);
-bool write_new_volume_label_to_dev(DCR *dcr, const char *VolName, const char *PoolName);
-bool write_session_label(DCR *dcr, DEV_BLOCK *block, int label);
-bool write_volume_label_to_block(DCR *dcr, DEV_BLOCK *block);
-void dump_volume_label(DEVICE *dev);
-void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose);
-bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec);
-bool unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec);
+int read_dev_volume_label(DCR *dcr, DEV_BLOCK *block);
+void create_session_label(DCR *dcr, DEV_RECORD *rec, int label);
+void create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName);
+bool write_new_volume_label_to_dev(DCR *dcr, const char *VolName, const char *PoolName);
+bool write_session_label(DCR *dcr, DEV_BLOCK *block, int label);
+bool write_volume_label_to_block(DCR *dcr, DEV_BLOCK *block);
+void dump_volume_label(DEVICE *dev);
+void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose);
+bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec);
+bool unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec);
/* From match_bsr.c */
-int match_bsr(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec,
- SESSION_LABEL *sesrec);
-int match_bsr_block(BSR *bsr, DEV_BLOCK *block);
-void position_bsr_block(BSR *bsr, DEV_BLOCK *block);
-BSR *find_next_bsr(BSR *root_bsr, DEVICE *dev);
-bool match_set_eof(BSR *bsr, DEV_RECORD *rec);
+int match_bsr(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec,
+ SESSION_LABEL *sesrec);
+int match_bsr_block(BSR *bsr, DEV_BLOCK *block);
+void position_bsr_block(BSR *bsr, DEV_BLOCK *block);
+BSR *find_next_bsr(BSR *root_bsr, DEVICE *dev);
+bool match_set_eof(BSR *bsr, DEV_RECORD *rec);
/* From mount.c */
-bool mount_next_write_volume(DCR *dcr, DEV_BLOCK *block, bool release);
-bool mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-void release_volume(JCR *jcr, DEVICE *dev);
-void mark_volume_in_error(JCR *jcr, DEVICE *dev);
+bool mount_next_write_volume(DCR *dcr, DEV_BLOCK *block, bool release);
+bool mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+void release_volume(JCR *jcr, DEVICE *dev);
+void mark_volume_in_error(JCR *jcr, DEVICE *dev);
/* From autochanger.c */
-int autoload_device(JCR *jcr, DEVICE *dev, int writing, BSOCK *dir);
-int autochanger_list(JCR *jcr, DEVICE *dev, BSOCK *dir);
-void invalidate_slot_in_catalog(JCR *jcr, DEVICE *dev);
+int autoload_device(DCR *dcr, int writing, BSOCK *dir);
+bool autochanger_list(DCR *dcr, BSOCK *dir);
+void invalidate_slot_in_catalog(DCR *dcr);
/* From parse_bsr.c */
-BSR *parse_bsr(JCR *jcr, char *lf);
-void dump_bsr(BSR *bsr, bool recurse);
-void free_bsr(BSR *bsr);
+BSR *parse_bsr(JCR *jcr, char *lf);
+void dump_bsr(BSR *bsr, bool recurse);
+void free_bsr(BSR *bsr);
VOL_LIST *new_vol();
-int add_vol(JCR *jcr, VOL_LIST *vol);
-void free_vol_list(JCR *jcr);
-void create_vol_list(JCR *jcr);
+int add_vol(JCR *jcr, VOL_LIST *vol);
+void free_vol_list(JCR *jcr);
+void create_vol_list(JCR *jcr);
/* From record.c */
const char *FI_to_ascii(int fi);
const char *stream_to_ascii(int stream, int fi);
-int write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
-int can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
-int read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec);
+int write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
+int can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
+int read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec);
DEV_RECORD *new_record();
-void free_record(DEV_RECORD *rec);
+void free_record(DEV_RECORD *rec);
/* From read_record.c */
bool read_records(DCR *dcr,
bool mount_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block));
/* From spool.c */
-bool begin_data_spool (JCR *jcr);
-bool discard_data_spool (JCR *jcr);
-bool commit_data_spool (JCR *jcr);
-bool are_attributes_spooled (JCR *jcr);
-bool begin_attribute_spool (JCR *jcr);
-bool discard_attribute_spool (JCR *jcr);
-bool commit_attribute_spool (JCR *jcr);
-bool write_block_to_spool_file (DCR *dcr, DEV_BLOCK *block);
-void list_spool_stats (BSOCK *bs);
+bool begin_data_spool (JCR *jcr);
+bool discard_data_spool (JCR *jcr);
+bool commit_data_spool (JCR *jcr);
+bool are_attributes_spooled (JCR *jcr);
+bool begin_attribute_spool (JCR *jcr);
+bool discard_attribute_spool (JCR *jcr);
+bool commit_attribute_spool (JCR *jcr);
+bool write_block_to_spool_file (DCR *dcr, DEV_BLOCK *block);
+void list_spool_stats (BSOCK *bs);
projects / bacula / bacula / commitdiff