void matr::mult(const extvec * b, extvec * r) {
#ifdef HAVE_THREADS
if (sstuff_get_threads() == 1) {
#endif
size_t J;
for (J = 0; J < rows(); J++) {
(*r)(J) = mult_line(J, b->const_begin(), b->const_end());
}
call_after_mult();
#ifdef HAVE_THREADS
} else {
size_t i;
size_t rws = rows();
size_t step = rws/(sstuff_get_threads());
size_t ost = rws % (sstuff_get_threads());
size_t J_from = 0;
size_t J_to = 0;
for (i = 0; i < sstuff_get_threads(); i++) {
J_to = J_from + step;
if (i == 0)
J_to += ost;
matr_mult_job & f = matr_mult_jobs[i];
f.set(this, b, r, J_from, J_to);
set_job(&f, i);
J_from = J_to;
}
do_jobs();
call_after_mult();
};
#endif
};
/*
* builtin_cmd - If the user has typed a built-in command then execute
* it immediately.
*/
int builtin_cmd(char **argv)
{
char *cmd = argv[0];
if (!strcmp(cmd, "help")) { /* quit command */
do_help();
return 1;
}
if (!strcmp(cmd, "stop")) { /* quit command */
do_stop(argv);
return 1;
}
if (!strcmp(cmd, "exit")) { /* quit command */
do_exit();
return 1;
}
if (!strcmp(cmd, "jobs")) { /* jobs command */
do_jobs();
return 1;
}
if (!strcmp(cmd, "bg")) { /* bg and fg commands */
do_bg(argv);
return 1;
}
if (!strcmp(cmd, "fg")) { /* bg and fg commands */
do_fg(argv);
return 1;
}
if (!strcmp(cmd, "kill")) { /* bg and fg commands */
do_kill(argv);
return 1;
}
return 0; /* not a builtin command */
}
void matr_rect::mult(const extvec * b, extvec * r) {
size_t J;
size_t i, j;
for (i = 0; i < b->size(); i++)
(*r)(i) = 0;
#ifdef HAVE_THREADS
if (sstuff_get_threads() == 1) {
#endif
for (j = y_from; j <= y_to; j++) {
for (i = x_from; i <= x_to; i++) {
J = i + j*n_grid_cols;
(*r)(J) = mult_line(J, b->const_begin(), b->const_end());
}
}
call_after_mult();
#ifdef HAVE_THREADS
} else {
size_t i;
size_t rws = y_to-y_from+1;
size_t step = rws/(sstuff_get_threads());
size_t ost = rws % (sstuff_get_threads());
size_t J_from = y_from;
size_t J_to = 0;
for (i = 0; i < sstuff_get_threads(); i++) {
J_to = J_from + step;
if (i == 0)
J_to += ost;
matr_rect_mult_job & f = matr_rect_mult_jobs[i];
f.set(this, b, r, J_from, J_to);
set_job(&f, i);
J_from = J_to;
}
do_jobs();
call_after_mult();
}
#endif
};
int main (int argc, char *argv[])
{
int i, ch;
FILE *fd;
char line[1000];
char *VolumeName = NULL;
char *bsrName = NULL;
char *DirectorName = NULL;
bool ignore_label_errors = false;
DIRRES *director = NULL;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
lmgr_init_thread();
working_directory = "/tmp";
my_name_is(argc, argv, "bls");
init_msg(NULL, NULL); /* initialize message handler */
OSDependentInit();
ff = init_find_files();
while ((ch = getopt(argc, argv, "b:c:D:d:e:i:jkLpvV:?")) != -1) {
switch (ch) {
case 'b':
bsrName = optarg;
break;
case 'c': /* specify config file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'D': /* specify director name */
if (DirectorName != NULL) {
free(DirectorName);
}
DirectorName = bstrdup(optarg);
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'e': /* exclude list */
if ((fd = fopen(optarg, "rb")) == NULL) {
berrno be;
Pmsg2(0, _("Could not open exclude file: %s, ERR=%s\n"),
optarg, be.bstrerror());
exit(1);
}
while (fgets(line, sizeof(line), fd) != NULL) {
strip_trailing_junk(line);
Dmsg1(100, "add_exclude %s\n", line);
add_fname_to_exclude_list(ff, line);
}
fclose(fd);
break;
case 'i': /* include list */
if ((fd = fopen(optarg, "rb")) == NULL) {
berrno be;
Pmsg2(0, _("Could not open include file: %s, ERR=%s\n"),
optarg, be.bstrerror());
exit(1);
}
while (fgets(line, sizeof(line), fd) != NULL) {
strip_trailing_junk(line);
Dmsg1(100, "add_include %s\n", line);
add_fname_to_include_list(ff, 0, line);
}
fclose(fd);
break;
case 'j':
list_jobs = true;
break;
case 'k':
list_blocks = true;
break;
case 'L':
dump_label = true;
break;
case 'p':
ignore_label_errors = true;
forge_on = true;
break;
case 'v':
verbose++;
break;
case 'V': /* Volume name */
VolumeName = optarg;
break;
case '?':
default:
usage();
} /* end switch */
} /* end while */
argc -= optind;
argv += optind;
if (!argc) {
Pmsg0(0, _("No archive name specified\n"));
usage();
}
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
my_config = new_config_parser();
parse_sd_config(my_config, configfile, M_ERROR_TERM);
LockRes();
me = (STORES *)GetNextRes(R_STORAGE, NULL);
if (!me) {
UnlockRes();
Emsg1(M_ERROR_TERM, 0, _("No Storage resource defined in %s. Cannot continue.\n"),
configfile);
}
UnlockRes();
if (DirectorName) {
foreach_res(director, R_DIRECTOR) {
if (bstrcmp(director->hdr.name, DirectorName)) {
break;
}
}
if (!director) {
Emsg2(M_ERROR_TERM, 0, _("No Director resource named %s defined in %s. Cannot continue.\n"),
DirectorName, configfile);
}
}
load_sd_plugins(me->plugin_directory, me->plugin_names);
read_crypto_cache(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
if (ff->included_files_list == NULL) {
add_fname_to_include_list(ff, 0, "/");
}
for (i=0; i < argc; i++) {
if (bsrName) {
bsr = parse_bsr(NULL, bsrName);
}
jcr = setup_jcr("bls", argv[i], bsr, director, VolumeName, 1); /* acquire for read */
if (!jcr) {
exit(1);
}
jcr->ignore_label_errors = ignore_label_errors;
dev = jcr->dcr->dev;
if (!dev) {
exit(1);
}
dcr = jcr->dcr;
rec = new_record();
attr = new_attr(jcr);
/*
* Assume that we have already read the volume label.
* If on second or subsequent volume, adjust buffer pointer
*/
if (dev->VolHdr.PrevVolumeName[0] != 0) { /* second volume */
Pmsg1(0, _("\n"
"Warning, this Volume is a continuation of Volume %s\n"),
dev->VolHdr.PrevVolumeName);
}
if (list_blocks) {
do_blocks(argv[i]);
} else if (list_jobs) {
do_jobs(argv[i]);
} else {
do_ls(argv[i]);
}
do_close(jcr);
}
if (bsr) {
free_bsr(bsr);
}
term_include_exclude_files(ff);
term_find_files(ff);
return 0;
}
int capfs_ftruncate64(int fd, int64_t length)
{
int i;
ireq req;
memset(&req, 0, sizeof(req));
/* check for badness */
if (fd < 0 || fd >= CAPFS_NR_OPEN
|| (pfds[fd] && pfds[fd]->fs == FS_RESV))
{
errno = EBADF;
return(-1);
}
/* check for UNIX */
if (!pfds[fd] || pfds[fd]->fs==FS_UNIX) {
#ifndef LARGE_FILE_SUPPORT
if ((off_t) length == length) {
return ftruncate(fd, (off_t) length);
}
else {
errno = EINVAL;
return(-1);
}
#else
return ftruncate64(fd, length);
#endif
}
if (pfds[fd]->fs == FS_PDIR) {
errno = EISDIR;
return(-1);
}
if (capfs_mode == 0)
{
req.majik_nr = IOD_MAJIK_NR;
req.release_nr = CAPFS_RELEASE_NR;
req.type = IOD_FTRUNCATE;
req.dsize = 0;
req.req.ftruncate.f_ino = FINO;
req.req.ftruncate.cap = pfds[fd]->fd.cap;
req.req.ftruncate.length = length;
/* build job to send reqs and recv acks */
if (build_simple_jobs(pfds[fd], &req) < 0) {
LOG(stderr, WARNING_MSG, SUBSYS_LIB, "capfs_ftruncate: build_simple_jobs failed\n");
return(-1);
}
/* call do_job */
while (!jlist_empty(active_p)) {
if (do_jobs(active_p, &socks, -1) < 0) {
LOG(stderr, WARNING_MSG, SUBSYS_LIB, "capfs_ftruncate: do_jobs failed\n");
return(-1);
}
}
/* check acks from iods */
for (i=0; i < PCNT; i++) {
if (pfds[fd]->fd.iod[i].ack.status) {
LOG(stderr, WARNING_MSG, SUBSYS_LIB, "capfs_ftruncate: non-zero status returned from iod %d\n", i);
errno = pfds[fd]->fd.iod[i].ack.eno;
return(-1);
}
}
}
return(0);
}
int capfs_read(int fd, char *buf, size_t count)
{
int i;
int64_t size = 0;
fdesc_p pfd_p = pfds[fd];
/* variables added for correct handling of EOF */
char *contacted;
int64_t exp_next_off, act_last_off, known_file_sz, calc_file_sz, start_off;
if (fd < 0 || fd >= CAPFS_NR_OPEN
|| (pfds[fd] && pfds[fd]->fs == FS_RESV)) {
errno = EBADF;
return(-1);
}
if (capfs_mode == 1) {
LOG(stderr, CRITICAL_MSG, SUBSYS_LIB, "capfs_read is not yet implemented for capfs! Please use"
"the VFS interface for accessing such files\n");
errno = ENOSYS;
return -1;
}
if (!pfd_p || pfd_p->fs == FS_UNIX) return(unix_read(fd, buf, count));
if (pfd_p->fs == FS_PDIR) return(unix_read(fd, buf, count));
#ifdef STRICT_FDESC_CHECK
if (do_fdesc_check(fd) < 0) {
LOG(stderr, CRITICAL_MSG, SUBSYS_LIB, "check failed at start of capfs_read()\n");
}
#endif
start_off = pfd_p->fd.off;
exp_next_off = pfd_p->fd.off + count;
known_file_sz = 0;
contacted = malloc(PCOUNT * sizeof(char));
for (i = 0; i < PCOUNT; i++) {
contacted[i] = 0;
pfd_p->fd.iod[i].ack.status = 0;
pfd_p->fd.iod[i].ack.dsize = 0;
}
/* build jobs, including requests and acks */
if (build_rw_jobs(pfd_p, buf, count, J_READ) < 0) {
LOG(stderr, WARNING_MSG, SUBSYS_LIB, "build_rw_jobs failed in capfs_read\n");
return(-1);
}
/* determine what iods we will contact */
for (i = 0; i < PCOUNT; i++) {
/* this isn't so efficient, but i don't want to muck with jlist imp. */
if (j_search(active_p, pfd_p->fd.iod[i].sock) != NULL) {
contacted[i] = 1;
}
}
/* send requests; receive data and acks */
while (!jlist_empty(active_p)) {
if (do_jobs(active_p, &socks, -1) < 0) {
PERROR(SUBSYS_LIB,"do_jobs");
free(contacted);
return(-1);
}
}
/* pass through responses, checking for errors, sizes */
for (i = 0; i < PCOUNT; i++) {
if (contacted[i]) {
if (pfd_p->fd.iod[i].ack.status) {
errno = pfd_p->fd.iod[i].ack.eno;
free(contacted);
return -1;
}
/* update known file size */
calc_file_sz = fsize_to_file_size(pfd_p->fd.iod[i].ack.ack.rw.fsize,
i, pfd_p);
size += pfd_p->fd.iod[i].ack.dsize;
if (calc_file_sz > known_file_sz) {
known_file_sz = calc_file_sz;
}
}
}
/* check for short read */
if (exp_next_off <= known_file_sz) {
/* we definitely did not hit EOF */
if (size < count) {
LOG(stderr, WARNING_MSG, SUBSYS_LIB, " capfs_read: hit hole, read %Ld of %d (everything should be ok)\n",
size, count);
}
pfd_p->fd.off = exp_next_off;
size = count; /* ensure correct return value (size might have hole) */
errno = 0;
}
else {
mack ack;
mreq req;
struct sockaddr saddr;
struct capfs_options opt;
opt.tcp = MGR_USE_TCP;
opt.use_hcache = 0;
/* we know we got a short read. it MIGHT be EOF, or it might just
* be that we hit a hole that happened to extend to the end of our
* region to read. we need to figure out which one happened.
*/
act_last_off = known_file_sz;
/* the quick and dirty way to figure out what happened is to
* stat() the file. a better solution would be to collect the
* remaining sizes from the iods we didn't already talk to.
*/
req.uid = getuid();
req.gid = getgid();
req.type = MGR_FSTAT;
req.dsize = 0;
req.req.fstat.meta = pfd_p->fd.meta;
saddr = pfd_p->fd.meta.mgr;
if (send_mreq_saddr(&opt, &saddr, &req, NULL, &ack, NULL) < 0 || ack.status != 0) {
PERROR(SUBSYS_LIB,"capfs_read: send_mreq_saddr - ");
/* error talking to mgr, but not really critical.
* assume we hit EOF, return what we know.
*/
pfd_p->fd.off = act_last_off;
size = act_last_off - start_off;
}
else {
/* got a response; determine if we hit EOF */
if (ack.ack.fstat.meta.u_stat.st_size > known_file_sz) {
/* the file is in fact bigger than we were told by the
* other iods
*/
known_file_sz = ack.ack.fstat.meta.u_stat.st_size;
}
if (exp_next_off <= known_file_sz) {
/* didn't really hit EOF */
if (size < count) {
LOG(stderr, WARNING_MSG, SUBSYS_LIB, " capfs_read: hit hole, read %Ld of %d (everything should be ok)\n",
size, count);
}
pfd_p->fd.off = exp_next_off;
size = count; /* ensure correct return value */
errno = 0;
}
else {
/* we really did hit EOF; return short read */
if(known_file_sz > start_off)
{
pfd_p->fd.off = known_file_sz;
size = known_file_sz - start_off;
errno = 0;
}
else
{
/* apparently tried to read after seeking beyond EOF;
* keep current offset but do not return any data
*/
pfd_p->fd.off = start_off;
size = 0;
errno = 0;
}
}
}
}
pfd_p->fd.meta.u_stat.atime = time(NULL);
LOG(stderr, DEBUG_MSG, SUBSYS_LIB, "capfs_read: completed %Ld bytes; new offset = %Ld\n", size,
pfd_p->fd.off);
#ifdef STRICT_FDESC_CHECK
if (do_fdesc_check(fd) < 0) {
LOG(stderr, CRITICAL_MSG, SUBSYS_LIB, "check failed at end of capfs_read()\n");
}
#endif
free(contacted);
return(size);
}
