> Currently my backup script is sequential.  I have been wondering if
> there is a way to use all my available drives but I don't want to go the
> way of using maxpr=2 because some of my backups are very large files
> like 60+ GB in size, I could be doing other things while that goes on.
>
> I would like to run two different backup stgpools and check every so
> often, if there is only one process running start another backup
> stgpool.
> When all my storage ppols are backed up, kick off the dbbackup
>
> I think I can handle most of the script through ifs and gotos but my
> problem is determining how many processes are currently running.  The
> SQL return codes don't seem to give me the results of a statement,
> unless I am reading the return codes wrong.
>
> So far what I have in mind (not exact syntax), and I have 4 drives so I
> want to run 2 concurrent backups
>
> If [processes] = 2 goto reschedule
> If [processes] = 1 goto startanotherbackup
> If [processes] = 0 and allbackupscomplete goto dbbackup, volhist,
> devconfig
>
> I think that I would control what backups I have already done through
> passing of script parameters.
>
> Am I off my rocker, or is something like this possible?

Offhand, I can only think of one way to do what you have in mind
with TSM server scripts: start all the backups, let them queue up
waiting for tape drives, and poll periodically to see if any
backups are still running. A script could check that by running
a 'select' command to select storage pool backups from the processes
table. A select that does not find any matching table entries will
end with a return code of 11.

That being said, I would be inclined to use scripting facilities
outside of TSM to manage multiple streams of storage pool backups.
I currently do this sort of thing for an OS/390 server using the
Rexx language and the Unix-like facilities provided by the USS
component of OS/390. If our server ran under Unix I could have
done the same thing using Perl. My script starts two background
processes and then goes into a loop in which each iteration waits
for a background process to end and starts another process.