bool CMapzoneData::MapZoneSpawned(CMapzone *mZone)
{
bool toReturn = false;
if (!mZone) return false;
char name[128];
if ( !ZoneTypeToClass( mZone->GetType(), name ) ) return false;
CBaseEntity *pEnt = gEntList.FindEntityByClassname(NULL, name);
while (pEnt)
{
if (pEnt->GetAbsOrigin() == *mZone->GetPosition()
&& pEnt->GetAbsAngles() == *mZone->GetRotation()
&& pEnt->WorldAlignMaxs() == *mZone->GetScaleMaxs()
&& pEnt->WorldAlignMins() == *mZone->GetScaleMins())
{
DevLog("Already found a %s spawned on the map! Not spawning it from zone file...\n", name);
toReturn = true;
break;
}
pEnt = gEntList.FindEntityByClassname(pEnt, name);
}
return toReturn;
}
void CTimer::PostTime()
{
if (steamapicontext->SteamHTTP() && steamapicontext->SteamUser() && !m_bWereCheatsActivated)
{
//Get required info
//MOM_TODO include the extra security measures for beta+
uint64 steamID = steamapicontext->SteamUser()->GetSteamID().ConvertToUint64();
const char* map = gpGlobals->mapname.ToCStr();
int ticks = gpGlobals->tickcount - m_iStartTick;
TickSet::Tickrate tickRate = TickSet::GetCurrentTickrate();
//Build URL
char webURL[512];
Q_snprintf(webURL, 512, "http://momentum-mod.org/postscore/%llu/%s/%i/%s", steamID, map,
ticks, tickRate.sType);
DevLog("Ticks sent to server: %i\n", ticks);
//Build request
mom_UTIL.PostTime(webURL);
}
else
{
Warning("Failed to post scores online: Cannot access STEAM HTTP or Steam User!\n");
}
}
void
init_transport(xport_state_t *transport)
{
int clear = 0;
xport_state_t *current = transport;
if (!(IS_GENERIC_API(transport->library->un->type))) {
for (; current != (xport_state_t *)0; current = current->next)
if (clear_transport(current->library, current))
clear++;
if (clear) {
dev_ent_t *un;
char *lc_mess;
SANITY_CHECK(transport != (xport_state_t *)0);
SANITY_CHECK(transport->library != (library_t *)0);
SANITY_CHECK(transport->library->un != (dev_ent_t *)0);
un = transport->library->un;
lc_mess = un->dis_mes[DIS_MES_CRIT];
memccpy(lc_mess,
catgets(catfd, SET, 9077,
"needs operator attention"),
'\0', DIS_MES_LEN);
DevLog(DL_ERR(5152));
DownDevice(un, SAM_STATE_CHANGE);
exit(1); /* this kill all threads */
}
}
cond_signal(&transport->condit); /* signal done */
}
void MomentumUtil::PostTimeCallback(HTTPRequestCompleted_t *pCallback, bool bIOFailure)
{
if (bIOFailure) return;
uint32 size;
steamapicontext->SteamHTTP()->GetHTTPResponseBodySize(pCallback->m_hRequest, &size);
DevLog("Size of body: %u\n", size);
uint8 *pData = new uint8[size];
steamapicontext->SteamHTTP()->GetHTTPResponseBodyData(pCallback->m_hRequest, pData, size);
DevLog("PostTimeCallback response: %s\n", reinterpret_cast<char*>(pData));
//MOM_TODO: Once the server updates this to contain more info, parse and do more with the response
// Necesary so TimeDisplay scoreboard knows it has to update;
IGameEvent *postEvent = gameeventmanager->CreateEvent("runtime_posted");
if (postEvent)
gameeventmanager->FireEvent(postEvent);
//Last but not least, free resources
steamapicontext->SteamHTTP()->ReleaseHTTPRequest(pCallback->m_hRequest);
}
void MomentumUtil::DownloadCallback(HTTPRequestCompleted_t *pCallback, bool bIOFailure)
{
if (bIOFailure) return;
FileHandle_t file;
//MOM_TODO: Read the MOM_TODO DownloadMap(), we're going to need to save the zone files too
file = filesystem->Open("testmapdownload.bsp", "w+b", "MOD");
uint32 size;
steamapicontext->SteamHTTP()->GetHTTPResponseBodySize(pCallback->m_hRequest, &size);
DevLog("Size of body: %u\n", size);
uint8 *pData = new uint8[size];
steamapicontext->SteamHTTP()->GetHTTPResponseBodyData(pCallback->m_hRequest, pData, size);
//write the file
filesystem->Write(pData, size, file);
//save the file
filesystem->Close(file);
DevLog("Successfully written file\n");
//Free resources
steamapicontext->SteamHTTP()->ReleaseHTTPRequest(pCallback->m_hRequest);
}
//This is only called when "map ____" is called, if the user uses changelevel then...
// \/(o_o)\/
void GameInit()
{
ConVarRef gm("mom_gamemode");
ConVarRef map("host_map");
const char *pMapName = map.GetString();
// This will only happen if the user didn't use the map selector to start a map
//set gamemode depending on map name
if (gm.GetInt() == MOMGM_UNKNOWN)
{
if (!Q_strnicmp(pMapName, "surf_", strlen("surf_")))
{
gm.SetValue(MOMGM_SURF);
//g_Timer.SetGameMode(MOMGM_SURF);
}
else if (!Q_strnicmp(pMapName, "bhop_", strlen("bhop_")))
{
DevLog("SETTING THE GAMEMODE!\n");
gm.SetValue(MOMGM_BHOP);
//DevLog("GOT TO #2 %i\n", m_iGameMode);
//g_Timer.SetGameMode(MOMGM_BHOP);
}
else if (!Q_strnicmp(pMapName, "kz_", strlen("kz_")))
{
DevLog("SETTING THE GAMEMODE!\n");
gm.SetValue(MOMGM_SCROLL);
}
else if (!Q_strcmp(pMapName, "background") || !Q_strcmp(pMapName, "credits"))
{
gm.SetValue(MOMGM_ALLOWED);
}
else
{
gm.SetValue(MOMGM_UNKNOWN);
//g_Timer.SetGameMode(MOMGM_UNKNOWN);
}
}
}
void CMomReplayManager::UnloadPlayback(bool shutdown)
{
SetPlayingBack(false);
if (m_pPlaybackReplay)
{
if (m_pPlaybackReplay->GetRunEntity() && !shutdown)
m_pPlaybackReplay->GetRunEntity()->EndRun();
delete m_pPlaybackReplay;
}
m_pPlaybackReplay = nullptr;
DevLog("Successfully unloaded playback, shutdown: %i\n", shutdown);
}
void
move_drive_error(
library_t *library,
uint_t source,
uint_t dest,
int *err)
{
/* Down the drive(s), not the robot */
int downed_one = 0;
drive_state_t *drive_to_down;
dev_ent_t *un = library->un;
uchar_t buf[library->ele_dest_len +
sizeof (element_status_data_t) + sizeof (element_status_page_t) +
50];
storage_element_t *desc;
if (drive_to_down = find_element(library->drive, source)) {
/* The source is a drive */
down_drive(drive_to_down, SAM_STATE_CHANGE);
downed_one++;
} else {
/*
* The source is not a drive. Read the storage element of the
* source. If full then set error to RECOVERED_MEDIA_MOVE. This
* tells the requester to set the CES_occupied status bit in the
* catalog entry.
*/
mutex_unlock(&library->un->io_mutex);
if (read_element_status(library, STORAGE_ELEMENT, source,
1, buf, sizeof (buf)) > 0) {
desc = (storage_element_t *)(buf +
sizeof (element_status_data_t) +
sizeof (element_status_page_t));
if (desc->full)
*err = RECOVERED_MEDIA_MOVE;
}
mutex_lock(&library->un->io_mutex);
}
if (drive_to_down = find_element(library->drive, dest)) {
down_drive(drive_to_down, SAM_STATE_CHANGE);
downed_one++;
}
if (downed_one == 0)
DevLog(DL_ERR(5333), source, dest, 0);
}
//Called upon map load, loads any and all times stored in the <mapname>.tim file
void CTimer::LoadLocalTimes(const char *szMapname)
{
char timesFilePath[MAX_PATH];
Q_strcpy(timesFilePath, c_mapDir);
Q_strcat(timesFilePath, szMapname, MAX_PATH);
Q_strncat(timesFilePath, c_timesExt, MAX_PATH);
KeyValues *timesKV = new KeyValues(szMapname);
if (timesKV->LoadFromFile(filesystem, timesFilePath, "MOD"))
{
for (KeyValues *kv = timesKV->GetFirstSubKey(); kv; kv = kv->GetNextKey())
{
Time t;
t.ticks = Q_atoi(kv->GetName());
t.tickrate = kv->GetFloat("rate");
t.date = (time_t) kv->GetInt("date");
localTimes.AddToTail(t);
}
}
else
{
DevLog("Failed to load local times; no local file was able to be loaded!\n");
}
timesKV->deleteThis();
}
void CMomentumPlayer::Spawn()
{
SetModel(ENTITY_MODEL);
SetBodygroup(1, 11);//BODY_PROLATE_ELLIPSE
// BASECLASS SPAWN MUST BE AFTER SETTING THE MODEL, OTHERWISE A NULL HAPPENS!
BaseClass::Spawn();
AddFlag(FL_GODMODE);
RemoveSolidFlags(FSOLID_NOT_SOLID); // this removes the flag that was added while switching to spectator mode which
// prevented the player from activating triggers
// do this here because we can't get a local player in the timer class
ConVarRef gm("mom_gamemode");
switch (gm.GetInt())
{
case MOMGM_BHOP:
case MOMGM_SURF:
case MOMGM_UNKNOWN:
default:
EnableAutoBhop();
break;
case MOMGM_SCROLL:
DisableAutoBhop();
break;
}
// Reset all bool gameevents
IGameEvent *runSaveEvent = gameeventmanager->CreateEvent("run_save");
IGameEvent *runUploadEvent = gameeventmanager->CreateEvent("run_upload");
IGameEvent *timerStartEvent = gameeventmanager->CreateEvent("timer_state");
m_RunData.m_bIsInZone = false;
m_RunData.m_bMapFinished = false;
m_RunData.m_iCurrentZone = 0;
m_bHasPracticeMode = false;
ResetRunStats();
if (runSaveEvent)
{
runSaveEvent->SetBool("run_saved", false);
gameeventmanager->FireEvent(runSaveEvent);
}
if (runUploadEvent)
{
runUploadEvent->SetBool("run_posted", false);
runUploadEvent->SetString("web_msg", "");
gameeventmanager->FireEvent(runUploadEvent);
}
if (timerStartEvent)
{
timerStartEvent->SetInt("ent", entindex());
timerStartEvent->SetBool("is_running", false);
gameeventmanager->FireEvent(timerStartEvent);
}
// Linear/etc map
g_Timer->DispatchMapInfo();
RegisterThinkContext("THINK_EVERY_TICK");
RegisterThinkContext("CURTIME");
RegisterThinkContext("THINK_AVERAGE_STATS");
RegisterThinkContext("CURTIME_FOR_START");
RegisterThinkContext("TWEEN");
SetContextThink(&CMomentumPlayer::UpdateRunStats, gpGlobals->curtime + gpGlobals->interval_per_tick,
"THINK_EVERY_TICK");
SetContextThink(&CMomentumPlayer::CheckForBhop, gpGlobals->curtime, "CURTIME");
SetContextThink(&CMomentumPlayer::CalculateAverageStats, gpGlobals->curtime + AVERAGE_STATS_INTERVAL,
"THINK_AVERAGE_STATS");
SetContextThink(&CMomentumPlayer::LimitSpeedInStartZone, gpGlobals->curtime, "CURTIME_FOR_START");
SetContextThink(&CMomentumPlayer::TweenSlowdownPlayer, gpGlobals->curtime, "TWEEN");
SetNextThink(gpGlobals->curtime);
DevLog("Finished spawn!\n");
}
/*
* -- setup_tapealert - Setup TapeAlert in polling mode. Disable
* recovered error check condition mode. Disable test mode. Set
* all other flags to the default values listed in the TapeAlert
* Specification v3.
*/
static void
setup_tapealert(dev_ent_t *un, int fd)
{
int resid; /* bytes not xfered */
#define LEN 255 /* max page len */
uchar_t page[LEN]; /* current page */
int i, len, offset; /* page variables */
#define PERF 0x80 /* performance */
#define EBF 0x20 /* enable background funcs */
#define EWASC 0x10 /* excpt warn chk cond */
#define DEXCPT 0x08 /* polling mode */
#define TEST 0x04 /* test mode */
#define LOGERR 0x01 /* logging of errors */
#define MIRE 0x03 /* tapealert mode */
#define MIRE_MASK 0x0f /* mire field */
sam_extended_sense_t *sense; /* device sense data ptr */
uchar_t pagechg[LEN]; /* changable page */
int offsetchg; /* chg page variables */
uchar_t cdb[SAM_CDB_LENGTH]; /* custom cdb */
/*
* Setup TapeAlert mode page in polling mode.
*/
memset(page, 0, LEN);
memset(pagechg, 0, LEN);
sense = (sam_extended_sense_t *)SHM_REF_ADDR(un->sense);
/* get current page */
if (scsi_cmd(fd, un, SCMD_MODE_SENSE, 30, page, LEN, 0x1c,
&resid) < 0) {
DevLog(DL_DEBUG(12009), sense->es_key, sense->es_add_code,
sense->es_qual_code);
goto done;
}
len = page[0]+1;
page[0] = 0;
offset = page[3];
page[4+offset] &= 0x7f;
/* get changeable page */
memset(cdb, 0, SAM_CDB_LENGTH);
cdb[0] = SCMD_MODE_SENSE;
if (IS_ROBOT(un)) {
cdb[1] = 0x08;
}
cdb[2] = 0x40 | 0x1c;
cdb[4] = LEN;
if (scsi_cmd(fd, un, SCMD_ISSUE_CDB, 30, cdb, 6, pagechg, LEN,
USCSI_READ, &resid) < 0) {
DevLog(DL_DEBUG(12010), sense->es_key, sense->es_add_code,
sense->es_qual_code);
goto done;
}
offsetchg = pagechg[3];
/*
* Change current TapeAlert page settings to polling mode.
*/
/* performance */
if ((pagechg[6+offsetchg] & PERF) == PERF) {
page[6+offset] &= ~PERF;
}
/* enable background functions */
if ((pagechg[6+offsetchg] & EBF) == EBF) {
page[6+offset] &= ~EBF;
}
/* exception warning reporting */
if ((pagechg[6+offsetchg] & EWASC) == EWASC) {
page[6+offset] &= ~EWASC;
}
/* disable exception control */
if ((pagechg[6+offsetchg] & DEXCPT) == DEXCPT) {
page[6+offset] |= DEXCPT;
}
/* test mode */
if ((pagechg[6+offsetchg] & TEST) == TEST) {
page[6+offset] &= ~TEST;
}
/* log err */
if ((pagechg[6+offsetchg] & LOGERR) == LOGERR) {
page[6+offset] &= ~LOGERR;
}
/* MIRE - field ignored if DEXCPT is set */
if ((pagechg[7+offsetchg] & MIRE_MASK) != 0) {
page[7+offset] &= ~(pagechg[7+offsetchg] & MIRE_MASK);
page[7+offset] |= (MIRE & pagechg[7+offsetchg]);
if ((page[7+offset] & MIRE_MASK) != MIRE) {
page[7+offset] &= ~MIRE_MASK;
}
}
/* interval timer */
for (i = 0; i < 4; i++) {
if (pagechg[i+8+offset] != 0) {
page[i+8+offset] &= ~(pagechg[i+8+offset]);
}
}
/* report count / test flag number */
for (i = 0; i < 4; i++) {
if (pagechg[i+12+offset] != 0) {
page[i+12+offset] &= ~(pagechg[i+12+offset]);
}
}
/* set polling mode and defaults */
memset(cdb, 0, SAM_CDB_LENGTH);
cdb[0] = SCMD_MODE_SELECT;
cdb[1] = 0x10; /* pf bit */
cdb[4] = len;
if (scsi_cmd(fd, un, SCMD_ISSUE_CDB, 30, cdb, 6, page, len,
USCSI_WRITE, &resid) < 0) {
DevLog(DL_DEBUG(12011), sense->es_key, sense->es_add_code,
sense->es_qual_code);
goto done;
}
done:
/* log run-time settings from current mode page query */
memset(page, 0, LEN);
if (scsi_cmd(fd, un, SCMD_MODE_SENSE, 30, page, LEN, 0x1c,
&resid) < 0) {
DevLog(DL_DEBUG(12012), sense->es_key, sense->es_add_code,
sense->es_qual_code);
return;
}
offset = page[3];
if (page[6+offset] != 8 || page[7+offset] != 3) {
DevLog(DL_DEBUG(12013), page[6+offset], page[7+offset]);
}
}
/*
* clean - clean the drive.
*
*/
void
clean(
drive_state_t *drive,
robo_event_t *event)
{
dev_ent_t *un;
int err, retry;
uint32_t access_count, status = 0;
char *d_mess;
char *l_mess;
struct CatalogEntry ced;
struct CatalogEntry *ce = &ced;
library_t *library;
move_flags_t move_flags;
SANITY_CHECK(drive != (drive_state_t *)0);
un = drive->un;
SANITY_CHECK(un != (dev_ent_t *)0);
library = (library_t *)drive->library;
SANITY_CHECK(library != (library_t *)0);
d_mess = drive->un->dis_mes[DIS_MES_NORM];
l_mess = library->un->dis_mes[DIS_MES_NORM];
mutex_lock(&drive->mutex);
if (clear_drive(drive)) {
mutex_lock(&drive->un->mutex);
drive->un->status.bits |= DVST_CLEANING;
mutex_unlock(&drive->un->mutex);
drive->status.b.cln_inprog = FALSE;
mutex_unlock(&drive->mutex);
disp_of_event(library, event, ENOENT);
return;
}
mutex_lock(&drive->un->mutex);
drive->un->status.bits |= (DVST_REQUESTED | DVST_CLEANING);
if (drive->un->open_count) {
clear_driver_idle(drive, drive->open_fd);
close_unit(drive->un, &drive->open_fd);
DEC_OPEN(un);
}
mutex_unlock(&drive->un->mutex);
mutex_unlock(&drive->mutex);
DevLog(DL_ALL(5075));
memccpy(d_mess, catgets(catfd, SET, 9025, "needs cleaning"),
'\0', DIS_MES_LEN);
ce = CatalogGetCleaningVolume(library->un->eq, &ced);
if (ce == NULL) {
memccpy(l_mess,
catgets(catfd, SET, 9026,
"no cleaning cartridge available"),
'\0', DIS_MES_LEN);
DevLog(DL_ERR(5141));
SendCustMsg(HERE, 9347);
mutex_lock(&drive->mutex);
drive->status.b.cln_inprog = FALSE;
down_drive(drive, SAM_STATE_CHANGE);
mutex_lock(&drive->un->mutex);
drive->un->status.bits &= ~DVST_REQUESTED;
mutex_unlock(&drive->un->mutex);
mutex_unlock(&drive->mutex);
disp_of_event(library, event, EAGAIN);
return;
} else {
status &= ~CES_occupied;
(void) CatalogSetFieldByLoc(ce->CeEq, ce->CeSlot, ce->CePart,
CEF_Status, status, CES_occupied);
}
if (library->un->equ_type == DT_3570C) {
clean_3570(drive, event, ce);
return;
}
mutex_lock(&drive->mutex);
if (IS_GENERIC_API(library->un->type)) {
int local_retry, d_errno, last_derrno = -1;
api_errs_t ret;
char *tag = "load on clean";
local_retry = 3;
ret = API_ERR_TR;
while (local_retry > 0) {
if (aci_load_media(library, drive, ce, &d_errno) == 0)
break;
else {
/* Error return on api call */
if (d_errno == 0) {
/*
* if call did not happen - error
* return but no error
*/
local_retry = -1;
d_errno = EAMUCOMM;
} else if ((last_derrno == -1) ||
(last_derrno != d_errno)) {
/* Save error if repeated */
last_derrno = d_errno;
if (api_valid_error(library->un->type,
d_errno, library->un)) {
/* Indentation for cstyle */
if (library->un->slot != ROBOT_NO_SLOT) {
DevLog(DL_DEBUG(6001),
library->un->slot, tag, d_errno,
d_errno, api_return_message(
library->un->type, d_errno));
} else {
DevLog(DL_DEBUG(6043), tag, d_errno,
d_errno, api_return_message(
library->un->type, d_errno));
}
local_retry = api_return_retry(
library->un->type, d_errno);
ret = api_return_degree(
library->un->type, d_errno);
} else {
local_retry = -2;
}
}
if (local_retry > 0) {
/* delay before retrying */
local_retry--;
if (local_retry > 0)
sleep(api_return_sleep(
library->un->type,
d_errno));
}
}
}
if (d_errno != EOK) {
DevLog(DL_ERR(6036), ce->CeBarCode);
memccpy(drive->un->dis_mes[DIS_MES_CRIT],
catgets(catfd, SET, 9029,
"unable to load cleaning cartridge, move failed"),
'\0', DIS_MES_LEN);
if (local_retry == -1) {
/* The call didn't happen */
DevLog(DL_ERR(6040), tag);
} else if (local_retry == 0) {
/* retries exceeded */
DevLog(DL_ERR(6039), tag);
} else {
if (api_valid_error(drive->library->un->type,
d_errno, drive->library->un)) {
if (drive->library->un->slot !=
ROBOT_NO_SLOT) {
DevLog(DL_ERR(6001),
drive->library->un->slot,
tag, d_errno, d_errno,
api_return_message(
library->un->type,
d_errno));
} else {
DevLog(DL_ERR(6043), tag,
d_errno, d_errno,
api_return_message(
library->un->type,
d_errno));
}
}
}
if (ret == API_ERR_DD)
down_drive(drive, SAM_STATE_CHANGE);
else if (ret == API_ERR_DM)
set_bad_media(un);
else if (ret == API_ERR_DL)
down_library(library, SAM_STATE_CHANGE);
drive->status.b.cln_inprog = FALSE;
mutex_lock(&drive->un->mutex);
drive->un->status.bits &= ~(DVST_CLEANING |
DVST_REQUESTED);
mutex_unlock(&drive->un->mutex);
mutex_unlock(&drive->mutex);
disp_of_event(library, event, EIO);
return;
}
} else {
move_flags.bits = 0;
memccpy(d_mess,
catgets(catfd, SET, 9009, "waiting for media changer"),
'\0', DIS_MES_LEN);
/*
* SPECTRA LOGIC NOTE: In 3.3.1, the invert argument on this
* move was set to one. This apparently was done for the
* spectra-logic robot which overloaded the invert argument
* to be the clean argument (See scsi_command case
* SCMD_MOVE_MEDIUM). Unfortunately, the Qualstar robot,
* which is mapped to the spectra-logic, implements the
* mailbox control for the same bit that spectra-logic uses
* as clean. Confused? Yep.
*
* Now to add to the confusion. Somewhere in the catalog
* rewrite, for reasons lost in the mists of time, the invert
* argument was set to zero. This is inadverentately half
* the fix for snap 4966. It simplifies things, ignoring any
* "special" cleaning logic and treating the cleaning tape as
* an ordinary load/unload. It seems to work.
*
* See #ifdef UNKNOWN_SPECTRA_LOGIC below for the other half of
* the fix.
*/
if (move_media(library, 0, ELEMENT_ADDRESS(library, ce->CeSlot),
drive->element, 0, move_flags)) {
memccpy(drive->un->dis_mes[DIS_MES_CRIT],
catgets(catfd, SET, 9029,
"unable to load cleaning cartridge, move failed"),
'\0', DIS_MES_LEN);
DevLog(DL_ERR(5143));
down_drive(drive, SAM_STATE_CHANGE);
drive->status.b.cln_inprog = FALSE;
mutex_unlock(&drive->mutex);
disp_of_event(library, event, EIO);
return;
}
}
mutex_unlock(&drive->mutex);
/*
* Log successful mount of cleaning tape
*/
DevLog(DL_ALL(10042), drive->un->eq);
tapeclean_media(drive->un);
/*
* move_media does not set up the un, so UpdateCatalog can't be
* called from here. Using generic_get_media instead of move_media
* leaves the drive hung up.
*/
status &= ~CES_occupied;
(void) CatalogSetFieldByLoc(ce->CeEq, ce->CeSlot, ce->CePart,
CEF_Status, status, CES_occupied);
access_count = ce->CeAccess;
access_count--;
(void) CatalogSetFieldByLoc(ce->CeEq, ce->CeSlot, ce->CePart,
CEF_Access, access_count, 0);
(void) CatalogSetFieldByLoc(ce->CeEq, ce->CeSlot, ce->CePart,
CEF_MountTime, time(NULL), 0);
retry = 7;
err = 0;
if (IS_GENERIC_API(library->un->equ_type)) {
char *tag = "unload for clean";
int local_retry, d_errno, last_derrno;
api_errs_t ret;
do {
memccpy(d_mess,
catgets(catfd, SET, 9030,
"waiting for cleaning cycle"),
'\0', DIS_MES_LEN);
sleep(3 * 60); /* wait 3 minutes */
tapeclean_media(drive->un);
mutex_lock(&drive->mutex);
memccpy(d_mess,
catgets(catfd, SET, 9031,
"attempt to unload cleaning cartridge"),
'\0', DIS_MES_LEN);
local_retry = 3;
ret = API_ERR_TR;
last_derrno = -1;
while (local_retry > 0) {
/*
* vsn is not set, use aci_force_media()
* instead of aci_dismount_media()
*/
if (aci_force_media(library, drive,
&d_errno) == 0)
break;
else {
/* Error return on api call */
if (d_errno == 0) {
/*
* if call did not happen -
* error return but no error
*/
local_retry = -1;
d_errno = EAMUCOMM;
} else if ((last_derrno == -1) ||
(last_derrno != d_errno)) {
/* Save error if repeated */
last_derrno = d_errno;
if (api_valid_error(
drive->library->un->type,
d_errno,
drive->library->un)) {
if (drive->library->un->slot !=
ROBOT_NO_SLOT) {
DevLog(DL_DEBUG(6001),
drive->library->un->slot,
tag, d_errno, d_errno,
api_return_message(
library->un->type,
d_errno));
} else {
DevLog(DL_DEBUG(6043),
tag, d_errno, d_errno,
api_return_message(
library->un->type,
d_errno));
}
local_retry = api_return_retry(
library->un->type, d_errno);
ret = api_return_degree(
library->un->type, d_errno);
} else {
local_retry = -2;
}
}
if (local_retry > 0) {
/* delay before retrying */
local_retry--;
if (local_retry > 0)
sleep(api_return_sleep(
library->un->type,
d_errno));
}
}
}
if (d_errno != EOK) {
DevLog(DL_ERR(6033), ce->CeBarCode);
if (local_retry == -1) {
/* The call didn't happen */
DevLog(DL_ERR(6040), tag);
} else if (local_retry == 0) {
/* retries exceeded */
DevLog(DL_ERR(6039), tag);
} else {
if (api_valid_error(
drive->library->un->type,
d_errno, drive->library->un))
if (drive->library->un->slot !=
ROBOT_NO_SLOT) {
DevLog(DL_ERR(6001),
drive->library->un->slot,
tag, d_errno, d_errno,
api_return_message(
library->un->type,
d_errno));
} else {
DevLog(DL_ERR(6043),
d_errno, d_errno,
api_return_message(
library->un->type,
d_errno));
}
}
if (ret == API_ERR_DL)
down_library(library, SAM_STATE_CHANGE);
else if (ret == API_ERR_DD)
down_drive(drive, SAM_STATE_CHANGE);
}
mutex_unlock(&drive->mutex);
} while (err != 0 && retry-- != 0);
} else {
/*
* SPECTRA LOGIC NOTE: Due to the removal of "special"
* cleaning code, we must unload the cleaning tape for all
* robot types.
*
* See the previous SPECTRA LOGIC NOTE:
*/
#ifdef UNKNOWN_SPECTRA_LOGIC
if (library->un->equ_type != DT_SPECLOG)
#endif
do {
memccpy(d_mess,
catgets(catfd, SET, 9030,
"wait for cleaning cycle"),
'\0', DIS_MES_LEN);
sleep(3 * 60); /* wait 3 minutes */
tapeclean_media(drive->un);
mutex_lock(&drive->mutex);
DevLog(DL_DETAIL(5077));
memccpy(d_mess,
catgets(catfd, SET, 9031,
"attempt to unload cleaning cartridge"),
'\0', DIS_MES_LEN);
err = move_media(library, 0, drive->element,
ELEMENT_ADDRESS(library, ce->CeSlot),
0, move_flags);
if (err) {
DevLog(DL_ERR(5078), retry);
} else {
DevLog(DL_DETAIL(5079));
}
mutex_unlock(&drive->mutex);
} while (err != 0 && retry-- != 0);
}
tapeclean_media(drive->un);
if (err != 0) {
DevLog(DL_ERR(5080));
memccpy(drive->un->dis_mes[DIS_MES_CRIT],
catgets(catfd, SET, 9032,
"unable to unload cleaning cartridge"),
'\0', DIS_MES_LEN);
mutex_lock(&drive->mutex);
drive->status.b.cln_inprog = FALSE;
down_drive(drive, SAM_STATE_CHANGE);
mutex_unlock(&drive->mutex);
disp_of_event(library, event, EIO);
return;
}
status = CES_occupied;
if (drive->un->status.b.bad_media) {
/* cleaning media marked in catalog as bad */
status |= CES_bad_media;
/* reset bad media flag */
drive->un->status.b.bad_media = 0;
}
(void) CatalogSetFieldByLoc(library->un->eq, ce->CeSlot, 0,
CEF_Status, status, 0);
DevLog(DL_ALL(5334), access_count);
if ((status & CES_bad_media) == 0) {
memccpy(d_mess,
catgets(catfd, SET, 9034, "drive has been cleaned"),
'\0', DIS_MES_LEN);
}
mutex_lock(&drive->mutex);
drive->status.b.cln_inprog = FALSE;
mutex_lock(&drive->un->mutex);
if ((status & CES_bad_media) == 0) {
/* drive was cleaned */
drive->un->status.bits &= ~(DVST_CLEANING | DVST_REQUESTED);
} else {
/* drive was not cleaned, it needs to still be cleaned */
drive->un->status.bits &= ~(DVST_REQUESTED);
}
mutex_unlock(&drive->un->mutex);
mutex_unlock(&drive->mutex);
if (ce->CeAccess == 0 || (status & CES_bad_media)) {
char *MES_9035 = catgets(catfd, SET, 9035,
"cleaning cartridge in slot %d has expired");
char *mess = (char *)malloc_wait(
strlen(MES_9035) + 15, 2, 0);
sprintf(mess, MES_9035, ce->CeSlot);
memccpy(l_mess, mess, '\0', DIS_MES_LEN);
free(mess);
switch (library->un->type) {
case DT_METD28:
case DT_DLT2700:
case DT_GRAUACI:
DevLog(DL_ERR(5144), ce->CeSlot);
break;
default:
schedule_export(library, ce->CeSlot);
DevLog(DL_ERR(5145), ce->CeSlot);
break;
}
} else if (tapeclean_drive(drive->un)) {
memccpy(l_mess,
catgets(catfd, SET, 2983, "clean failed"),
'\0', DIS_MES_LEN);
DevLog(DL_ERR(5364));
mutex_lock(&drive->mutex);
down_drive(drive, SAM_STATE_CHANGE);
mutex_unlock(&drive->mutex);
disp_of_event(library, event, EIO);
return;
}
disp_of_event(library, event, 0);
}
bool CMapzoneData::LoadFromFile(const char *szMapName)
{
bool toReturn = false;
char zoneFilePath[MAX_PATH];
Q_strcpy(zoneFilePath, c_mapPath);
Q_strcat(zoneFilePath, szMapName, MAX_PATH);
Q_strncat(zoneFilePath, c_zoneFileEnding, MAX_PATH);
DevLog("Looking for zone file: %s \n", zoneFilePath);
KeyValues* zoneKV = new KeyValues(szMapName);
if (zoneKV->LoadFromFile(filesystem, zoneFilePath, "MOD"))
{
// Go through checkpoints
for (KeyValues *cp = zoneKV->GetFirstSubKey(); cp; cp = cp->GetNextKey())
{
// Load position information (will default to 0 if the keys don't exist)
Vector* pos = new Vector(cp->GetFloat("xPos"), cp->GetFloat("yPos"), cp->GetFloat("zPos"));
QAngle* rot = new QAngle(cp->GetFloat("xRot"), cp->GetFloat("yRot"), cp->GetFloat("zRot"));
Vector* scaleMins = new Vector(cp->GetFloat("xScaleMins"), cp->GetFloat("yScaleMins"), cp->GetFloat("zScaleMins"));
Vector* scaleMaxs = new Vector(cp->GetFloat("xScaleMaxs"), cp->GetFloat("yScaleMaxs"), cp->GetFloat("zScaleMaxs"));
// Do specific things for different types of checkpoints
// 0 = start, 1 = checkpoint, 2 = end, 3 = Onehop, 4 = OnehopReset, 5 = Checkpoint_teleport, 6 = Multihop, 7 = stage
int zoneType = -1;
int index = -1;
bool shouldStop = false;
bool shouldTilt = true;
float holdTime = 1.0f;
//int destinationIndex = -1;
bool limitingspeed = true;
float maxleavespeed = 290.0f;
const char * linkedtrigger = NULL;
if (Q_strcmp(cp->GetName(), "start") == 0)
{
zoneType = MOMZONETYPE_START;
limitingspeed = cp->GetBool("limitingspeed");
maxleavespeed = cp->GetFloat("leavespeed");
}
else if (Q_strcmp(cp->GetName(), "checkpoint") == 0)
{
zoneType = MOMZONETYPE_CP;
index = cp->GetInt("number", -1);
}
else if (Q_strcmp(cp->GetName(), "end") == 0)
{
zoneType = MOMZONETYPE_STOP;
}
else if (Q_strcmp(cp->GetName(), "onehop") == 0)
{
zoneType = MOMZONETYPE_ONEHOP;
shouldStop = cp->GetBool("stop", false);
shouldTilt = cp->GetBool("resetang", true);
holdTime = cp->GetFloat("hold", 1);
//destinationIndex = cp->GetInt("destination", 1);
linkedtrigger = cp->GetString("destinationname", NULL);
}
else if (Q_strcmp(cp->GetName(), "resetonehop") == 0)
{
zoneType = MOMZONETYPE_RESETONEHOP;
}
else if (Q_strcmp(cp->GetName(), "checkpoint_teleport") == 0)
{
zoneType = MOMZONETYPE_CPTELE;
//destinationIndex = cp->GetInt("destination", -1);
shouldStop = cp->GetBool("stop", false);
shouldTilt = cp->GetBool("resetang", true);
linkedtrigger = cp->GetString("destinationname", NULL);
}
else if (Q_strcmp(cp->GetName(), "multihop") == 0)
{
zoneType = MOMZONETYPE_MULTIHOP;
shouldStop = cp->GetBool("stop", false);
shouldTilt = cp->GetBool("resetang", true);
holdTime = cp->GetFloat("hold", 1);
//destinationIndex = cp->GetInt("destination", 1);
linkedtrigger = cp->GetString("destinationname", NULL);
}
else if (Q_strcmp(cp->GetName(), "stage") == 0)
{
zoneType = MOMZONETYPE_STAGE;
index = cp->GetInt("number", 0);
}
else
{
Warning("Error while reading zone file: Unknown mapzone type %s!\n", cp->GetName());
continue;
}
// Add element
m_zones.AddToTail(new CMapzone(zoneType, pos, rot, scaleMins, scaleMaxs, index, shouldStop, shouldTilt,
holdTime, limitingspeed, maxleavespeed, MAKE_STRING(linkedtrigger)));
}
DevLog("Successfully loaded map zone file %s!\n", zoneFilePath);
toReturn = true;
}
zoneKV->deleteThis();
return toReturn;
}
/*
* audit - start auditing
*
*
*/
void
audit(
drive_state_t *drive, /* drive state pointer */
const uint_t slot, /* slot to audit */
const int audit_eod)
{ /* flag to find eod during audit */
int part, err;
uint_t myslot = 0;
dev_ent_t *un;
sam_defaults_t *defaults;
struct CatalogEntry ced;
struct CatalogEntry *ce = &ced;
int skip_audit_eod = 0;
defaults = GetDefaults();
SANITY_CHECK(drive != (drive_state_t *)0);
SANITY_CHECK(drive->library != (library_t *)0);
SANITY_CHECK(drive->library->un != (dev_ent_t *)0);
SANITY_CHECK(drive->library->un != drive->un);
un = drive->un;
if ((slot == ROBOT_NO_SLOT) &&
IS_GENERIC_API(drive->library->un->type)) {
DevLog(DL_ERR(6004));
return;
}
mutex_lock(&drive->mutex);
if (drive->status.b.full) {
mutex_lock(&un->mutex);
un->status.b.requested = TRUE;
mutex_unlock(&un->mutex);
if (clear_drive(drive)) {
mutex_lock(&un->mutex);
un->status.b.requested = TRUE;
mutex_unlock(&un->mutex);
mutex_unlock(&drive->mutex);
return;
}
if (drive->open_fd >= 0) {
mutex_lock(&un->mutex);
close_unit(un, &drive->open_fd);
DEC_OPEN(un);
mutex_unlock(&un->mutex);
}
}
mutex_unlock(&drive->mutex);
mutex_lock(&un->mutex);
un->status.b.requested = TRUE;
un->status.b.labeled = FALSE;
un->status.b.ready = FALSE;
mutex_unlock(&un->mutex);
if (slot == ROBOT_NO_SLOT) {
mutex_lock(&drive->library->mutex);
drive->library->countdown--;
drive->library->drives_auditing++;
mutex_unlock(&drive->library->mutex);
/*
* ok not to lock here wait for all drives to clear
*/
while (drive->library->countdown > 0)
sleep(4);
}
for (;;) {
mutex_lock(&drive->mutex);
if (slot == ROBOT_NO_SLOT) {
/* get the next slot number (s) */
mutex_lock(&drive->library->mutex);
myslot = drive->library->audit_index;
if (myslot <= drive->library->range.storage_count) {
drive->library->audit_index++;
mutex_unlock(&drive->library->mutex);
} else {
/* No more slots to audit */
mutex_unlock(&drive->library->mutex);
mutex_lock(&drive->library->un->mutex);
drive->library->un->status.b.mounted = TRUE;
drive->library->un->status.b.audit = FALSE;
drive->library->un->status.b.ready = TRUE;
mutex_unlock(&drive->library->un->mutex);
if (drive->status.b.full) {
clear_drive(drive);
if (drive->open_fd >= 0)
mutex_lock(&un->mutex);
close_unit(un, &drive->open_fd);
mutex_unlock(&un->mutex);
}
mutex_lock(&un->mutex);
un->status.b.requested = FALSE;
mutex_unlock(&un->mutex);
mutex_unlock(&drive->mutex);
return;
}
} else {
/* get specific slot */
myslot = slot;
}
/*
* Should we audit this media? (is occupied, not cleaning and
* is a sam tape)
*/
if (drive->library->status.b.two_sided) {
part = 1;
} else {
part = 0;
}
ce = CatalogGetCeByLoc(drive->library->un->eq,
myslot, part, &ced);
if (ce == NULL ||
(!(ce->CeStatus & CES_occupied)) ||
(ce->CeStatus & CES_cleaning) ||
(ce->CeStatus & CES_non_sam)) {
mutex_unlock(&drive->mutex);
if (slot != ROBOT_NO_SLOT) { /* only one slot */
mutex_lock(&un->mutex);
un->status.b.requested = FALSE;
mutex_unlock(&un->mutex);
return;
}
continue;
}
/*
* The following lines of code get a tape mounted, or if
* two-sided media, mounts the "A" side.
*/
err = get_media(drive->library, drive, NULL, ce);
if (err) {
mutex_lock(&un->mutex);
un->status.b.requested = FALSE;
DEC_ACTIVE(un);
mutex_unlock(&un->mutex);
mutex_unlock(&drive->mutex);
return;
}
mutex_lock(&un->mutex);
un->status.b.scanning = TRUE;
mutex_unlock(&un->mutex);
if (spin_drive(drive, SPINUP, NOEJECT)) {
mutex_lock(&drive->un->mutex);
drive->un->status.b.scanning &= ~DVST_SCANNING;
drive->un->status.bits &= ~DVST_REQUESTED;
mutex_unlock(&drive->un->mutex);
if (un->state > DEV_ON) {
clear_drive(drive);
mutex_lock(&un->mutex);
clear_driver_idle(drive, drive->open_fd);
DEC_ACTIVE(un);
close_unit(un, &drive->open_fd);
mutex_unlock(&un->mutex);
mutex_unlock(&drive->mutex);
} else {
mutex_lock(&un->mutex);
clear_driver_idle(drive, drive->open_fd);
DEC_ACTIVE(un);
close_unit(un, &drive->open_fd);
mutex_unlock(&un->mutex);
mutex_unlock(&drive->mutex);
}
SendCustMsg(HERE, 9348);
DevLog(DL_ERR(5218));
return;
}
un->status.bits |= DVST_AUDIT;
un->mid = ce->CeMid;
un->status.b.labeled = FALSE;
un->i.ViPart = ce->CePart;
scan_a_device(un, drive->open_fd);
if (drive->status.b.bar_code) {
(void) CatalogSetStringByLoc(drive->library->un->eq,
ce->CeSlot, ce->CePart,
CEF_BarCode, (char *)drive->bar_code);
}
/*
* If the cleaning light came on while scanning, leave the
* audit bit set and unload the drive.
*/
if (un->status.bits & DVST_CLEANING) {
mutex_lock(&un->mutex);
un->mtime = 0;
DEC_ACTIVE(un);
close_unit(un, &drive->open_fd);
un->status.b.requested = FALSE;
mutex_unlock(&un->mutex);
clear_drive(drive);
mutex_unlock(&drive->mutex);
return;
} else {
un->status.bits &= ~DVST_AUDIT;
}
mutex_lock(&un->mutex);
/*
* This next check keeps us from auditing media that is not
* really labeled (label lie). I'm not sure why the un->mutex
* is held for this.
*/
if (!un->status.b.labeled &&
(ce->CeStatus & CES_bar_code) &&
(defaults->flags & DF_LABEL_BARCODE)) {
int tmp;
if (IS_TAPE(un)) {
tmp = LEN_TAPE_VSN;
} else {
tmp = LEN_OPTIC_VSN;
}
vsn_from_barcode(un->vsn, ce->CeBarCode, defaults, tmp);
un->status.b.labeled = TRUE;
un->space = un->capacity;
skip_audit_eod = 1;
}
if (IS_TAPE(un)) {
if (un->status.b.labeled &&
audit_eod && !skip_audit_eod) {
DevLog(DL_DETAIL(5074), un->vsn);
mutex_unlock(&un->mutex);
mutex_lock(&un->io_mutex);
tape_append(drive->open_fd, un, NULL);
mutex_unlock(&un->io_mutex);
mutex_lock(&un->mutex);
} else {
if (!un->status.b.labeled) {
un->space = un->capacity;
} else {
un->space = ce->CeSpace;
}
}
}
UpdateCatalog(un, 0, CatalogVolumeLoaded);
/*
* Now do the "B" side if this is optical media.
* flip_and_scan calls CatalogVolumeLoaded so it is not done
* here.
*/
if (drive->library->status.b.two_sided && (ce->CePart == 1)) {
mutex_unlock(&un->mutex);
if (flip_and_scan(ce->CePart, drive)) {
clear_drive(drive);
mutex_lock(&un->mutex);
un->status.b.requested = FALSE;
clear_driver_idle(drive, drive->open_fd);
close_unit(un, &drive->open_fd);
DEC_ACTIVE(un);
mutex_unlock(&un->mutex);
mutex_unlock(&drive->mutex);
return;
}
mutex_unlock(&drive->mutex);
} else {
mutex_unlock(&un->mutex);
mutex_unlock(&drive->mutex);
}
mutex_lock(&un->mutex);
close_unit(un, &drive->open_fd);
DEC_ACTIVE(un);
un->status.b.requested = TRUE;
mutex_unlock(&un->mutex);
if (slot != ROBOT_NO_SLOT) { /* only one slot */
mutex_lock(&un->mutex);
un->status.b.requested = FALSE;
mutex_unlock(&un->mutex);
mutex_lock(&drive->library->un->mutex);
drive->library->un->status.b.mounted = TRUE;
mutex_unlock(&drive->library->un->mutex);
return;
}
}
}
static int luasrc_DevLog (lua_State *L) {
DevLog(luaL_checkstring(L, 1));
return 0;
}
/*
* --- get_supports_tapealert - determine if the robot or tape drive supports
* TapeAlert.
*/
void
get_supports_tapealert(dev_ent_t *un, int fd)
{
int local_open = 0;
int open_fd;
sam_extended_sense_t *sense;
#define PAGE_LEN 256
char page[PAGE_LEN], *page_ptr;
int i, page_len, resid;
boolean_t unlock_needed = B_FALSE;
/* Feature check. */
if ((un->tapealert & TAPEALERT_ENABLED) == 0) {
return;
}
/* Clear previous success flag. */
un->tapealert &= ~TAPEALERT_SUPPORTED;
/* Only tape drives and robots. */
if (un->scsi_type != 1 && un->scsi_type != 8) {
return;
}
/* Local file descriptor open used by fifo command message. */
if (fd < 0) {
if ((open_fd = open(un->name, O_RDONLY | O_NONBLOCK)) < 0) {
if (IS_TAPE(un)) {
char *open_name;
if ((open_fd = open((open_name =
samst_devname(un)),
O_RDONLY | O_NONBLOCK)) < 0) {
if (open_name != (char *)
un->dt.tp.samst_name)
free(open_name);
return;
} else {
INC_OPEN(un);
if (open_name != (char *)
un->dt.tp.samst_name)
free(open_name);
local_open = TRUE;
}
} else {
DevLog(DL_DEBUG(12014));
return;
}
} else {
INC_OPEN(un);
local_open = TRUE;
}
} else {
open_fd = fd;
}
/* Look for log sense tapealert page 0x2e */
sense = (sam_extended_sense_t *)SHM_REF_ADDR(un->sense);
(void) memset(sense, 0, sizeof (sam_extended_sense_t));
if (mutex_trylock(&un->io_mutex) == 0) {
unlock_needed = B_TRUE;
}
memset(page, 0, PAGE_LEN);
if (scsi_cmd(open_fd, un, SCMD_LOG_SENSE, 0, page, 0, 0, 0,
PAGE_LEN, &resid) >= 0) {
page_len = ((PAGE_LEN - resid) >= 4 ? (PAGE_LEN - resid) : 0);
if (page_len >= 4) {
page_len = (page[2] << 8) | page[3];
page_ptr = page + 4;
}
for (i = 0; i < page_len; i++) {
if (page_ptr[i] == 0x2e) {
/* initialize tapealert data */
un->tapealert |= TAPEALERT_SUPPORTED;
un->tapealert_flags = 0;
un->tapealert_vsn[0] = '\0';
DevLog(DL_ALL(12001));
setup_tapealert(un, open_fd);
break;
}
}
}
/* query, clear, and report active flags at setup */
un->tapealert |= TAPEALERT_INIT_QUERY;
TAPEALERT(open_fd, un);
un->tapealert &= ~TAPEALERT_INIT_QUERY;
if (unlock_needed == B_TRUE) {
mutex_unlock(&un->io_mutex);
}
if (local_open) {
(void) close(open_fd);
DEC_OPEN(un);
}
}
/*
* clean_3570 - attempt to load cleaning tape into 3570.
*/
void
clean_3570(
drive_state_t *drive,
robo_event_t *event,
struct CatalogEntry *ce)
{
int retry;
char *dev_name;
char *d_mess = drive->un->dis_mes[DIS_MES_NORM];
dev_ent_t *un = drive->un;
library_t *library = drive->library;
move_flags_t move_flags;
mutex_lock(&drive->mutex);
move_flags.bits = 0;
/*
* The 3570 does not return from the move until the cleaning cycle
* has completed.
*/
memccpy(d_mess, catgets(catfd, SET, 9030, "wait for cleaning cycle"),
'\0', DIS_MES_LEN);
if (generic_get_media(library, drive, event, ce)) {
memccpy(drive->un->dis_mes[DIS_MES_CRIT],
catgets(catfd, SET, 9029,
"unable to load cleaning cartridge, move failed"),
'\0', DIS_MES_LEN);
DevLog(DL_ERR(5145), ce->CeSlot);
down_drive(drive, SAM_STATE_CHANGE);
drive->status.b.cln_inprog = FALSE;
mutex_unlock(&drive->mutex);
disp_of_event(library, event, EIO);
return;
}
mutex_unlock(&drive->mutex);
sleep(4);
dev_name = samst_devname(un);
mutex_lock(&un->mutex);
drive->open_fd = open_unit(un, dev_name, 10);
mutex_unlock(&un->mutex);
free(dev_name);
un->i.ViEq = un->fseq;
un->i.ViSlot = un->slot;
un->i.ViPart = 0;
un->i.ViFlags = VI_cart;
UpdateCatalog(drive->un, 0, CatalogVolumeLoaded);
/* Wait for cleaning to finish */
retry = 60;
while (retry--) {
sam_extended_sense_t *sense = (sam_extended_sense_t *)
SHM_REF_ADDR(un->sense);
mutex_lock(&un->io_mutex);
memset(sense, 0, sizeof (sam_extended_sense_t));
if (scsi_cmd(drive->open_fd, un, SCMD_TEST_UNIT_READY, 20) ||
sense->es_key != 0) {
/* If cleaning in progress */
if (sense->es_key == 0x02 &&
sense->es_add_code == 0x30 &&
sense->es_qual_code == 0x03) {
mutex_unlock(&un->io_mutex);
sleep(30);
continue;
}
if (sense->es_key == 0x06 &&
sense->es_add_code == 0x82 &&
sense->es_qual_code == 0x83)
break;
mutex_unlock(&un->io_mutex);
sprintf(d_mess, "sense %x, %x, %x", sense->es_key,
sense->es_add_code, sense->es_qual_code);
sleep(10);
}
}
if (retry <= 0)
DevLog(DL_ERR(5216));
memccpy(d_mess, catgets(catfd, SET, 9034, "drive has been cleaned"),
'\0', DIS_MES_LEN);
mutex_unlock(&un->io_mutex);
mutex_lock(&un->mutex);
close_unit(un, &drive->open_fd);
mutex_unlock(&un->mutex);
mutex_lock(&drive->mutex);
move_flags.bits = 0;
memccpy(d_mess,
catgets(catfd, SET, 9009, "waiting for media changer"),
'\0', DIS_MES_LEN);
if (move_media(library, 0, drive->element, 0xff, 1, move_flags)) {
memccpy(drive->un->dis_mes[DIS_MES_CRIT],
catgets(catfd, SET, 9032,
"unable to unload cleaning cartridge"),
'\0', DIS_MES_LEN);
DevLog(DL_ERR(5147));
drive->status.b.cln_inprog = FALSE;
down_drive(drive, SAM_STATE_CHANGE);
mutex_unlock(&drive->mutex);
disp_of_event(library, event, EIO);
return;
}
if (CatalogVolumeUnloaded(&un->i, "") == -1) {
DevLog(DL_SYSERR(5336), ce->CeSlot);
}
drive->status.b.cln_inprog = FALSE;
mutex_lock(&drive->un->mutex);
drive->un->status.bits &= ~(DVST_CLEANING | DVST_REQUESTED);
un->label_time = 0;
mutex_unlock(&drive->un->mutex);
mutex_unlock(&drive->mutex);
disp_of_event(library, event, 0);
}
void CTriggerTimerStop::StartTouch(CBaseEntity *pOther)
{
CMomentumPlayer *pPlayer = ToCMOMPlayer(pOther);
IGameEvent *stageEvent = nullptr;
// If timer is already stopped, there's nothing to stop (No run state effect to play)
if (pPlayer)
{
g_Timer->SetEndTrigger(this);
if (g_Timer->IsRunning() && !pPlayer->IsWatchingReplay())
{
int zoneNum = pPlayer->m_RunData.m_iCurrentZone;
// This is needed so we have an ending velocity.
pPlayer->m_RunStats.SetZoneExitSpeed(zoneNum, pPlayer->GetLocalVelocity().Length(), pPlayer->GetLocalVelocity().Length2D());
//Check to see if we should calculate the timer offset fix
if (ContainsPosition(pPlayer->GetPrevOrigin()))
DevLog("PrevOrigin inside of end trigger, not calculating offset!\n");
else
{
DevLog("Previous origin is NOT inside the trigger, calculating offset...\n");
g_Timer->CalculateTickIntervalOffset(pPlayer, g_Timer->ZONETYPE_END);
}
//This is needed for the final stage
pPlayer->m_RunStats.SetZoneTime(zoneNum,
g_Timer->GetCurrentTime() -
pPlayer->m_RunStats.GetZoneEnterTime(zoneNum));
//Ending velocity checks
float endvel = pPlayer->GetLocalVelocity().Length();
float endvel2D = pPlayer->GetLocalVelocity().Length2D();
float finalVel = endvel;
float finalVel2D = endvel2D;
if (endvel <= pPlayer->m_RunStats.GetZoneVelocityMax(0, false))
finalVel = pPlayer->m_RunStats.GetZoneVelocityMax(0, false);
if (endvel2D <= pPlayer->m_RunStats.GetZoneVelocityMax(0, true))
finalVel2D = pPlayer->m_RunStats.GetZoneVelocityMax(0, true);
pPlayer->m_RunStats.SetZoneVelocityMax(0, finalVel, finalVel2D);
pPlayer->m_RunStats.SetZoneExitSpeed(0, endvel, endvel2D);
//Stop the timer
g_Timer->Stop(true);
pPlayer->m_RunData.m_flRunTime = g_Timer->GetLastRunTime();
//The map is now finished, show the mapfinished panel
pPlayer->m_RunData.m_bMapFinished = true;
pPlayer->m_RunData.m_bTimerRunning = false;
}
stageEvent = gameeventmanager->CreateEvent("zone_enter");
pPlayer->m_RunData.m_bIsInZone = true;
}
else
{
CMomentumReplayGhostEntity *pGhost = dynamic_cast<CMomentumReplayGhostEntity*>(pOther);
if (pGhost)
{
stageEvent = gameeventmanager->CreateEvent("zone_enter");
pGhost->m_RunData.m_bMapFinished = true;
pGhost->m_RunData.m_bTimerRunning = false;
pGhost->m_RunData.m_bIsInZone = true;
//Needed for hud_comparisons
IGameEvent *timerStateEvent = gameeventmanager->CreateEvent("timer_state");
if (timerStateEvent)
{
timerStateEvent->SetInt("ent", pGhost->entindex());
timerStateEvent->SetBool("is_running", false);
gameeventmanager->FireEvent(timerStateEvent);
}
pGhost->StopTimer();
//MOM_TODO: Maybe play effects if the player is racing against us and lost?
}
}
//Used by speedometer
if (stageEvent)
{
gameeventmanager->FireEvent(stageEvent);
}
BaseClass::StartTouch(pOther);
}
/*
* init_elements - get status for all elements in the library.
*
* exit -
*/
int /* 0 = all ok !0 = failure */
init_elements(
library_t *library)
{
uint16_t count, start_element;
uint16_t avail_drives;
int i, err, conlevel = 5;
size_t retry;
dev_ent_t *un;
char *drv_tbl;
mode_sense_t *mode_sense;
drive_state_t *drive;
xport_state_t *xport;
iport_state_t *import;
robot_ms_page1d_t *pg1d = NULL;
robot_ms_page1e_t *pg1e = NULL;
robot_ms_page1f_t *pg1f = NULL;
sam_extended_sense_t *sense;
SANITY_CHECK(library != (library_t *)0);
un = library->un;
SANITY_CHECK(un != (dev_ent_t *)0);
/* Put mode sense data into shared memory. */
/* LINTED pointer cast may result in improper alignment */
mode_sense = (mode_sense_t *)SHM_REF_ADDR(un->mode_sense);
sense = (sam_extended_sense_t *)SHM_REF_ADDR(un->sense);
SANITY_CHECK(mode_sense != (mode_sense_t *)0);
SANITY_CHECK(sense != (sam_extended_sense_t *)0);
(void) memset(mode_sense, 0, sizeof (mode_sense_t));
mutex_lock(&un->io_mutex);
pg1d = (robot_ms_page1d_t *)lib_mode_sense(library, 0x1d,
(uchar_t *)& mode_sense->u.robot_ms.pg1d,
sizeof (robot_ms_page1d_t));
pg1f = (robot_ms_page1f_t *)lib_mode_sense(library, 0x1f,
(uchar_t *)& mode_sense->u.robot_ms.pg1f,
sizeof (robot_ms_page1f_t));
pg1e = (robot_ms_page1e_t *)lib_mode_sense(library, 0x1e,
(uchar_t *)& mode_sense->u.robot_ms.pg1e,
sizeof (robot_ms_page1e_t));
mutex_unlock(&un->io_mutex);
if (pg1d == NULL || pg1f == NULL || pg1e == NULL) {
DevLog(DL_ERR(5115));
return (1);
}
library->status.b.two_sided = pg1e->transport_sets[0].rotate;
if (un->type == DT_CYGNET)
library->status.b.two_sided = 0;
/* Allocate the drive tables. */
BE16toH(&pg1d->first_drive, &start_element);
BE16toH(&pg1d->num_drive, &count);
library->range.drives_lower = start_element;
library->range.drives_count = count;
library->range.drives_upper = start_element + count - 1;
/*
* This code is currently applied to IBM3584 only since the IBM3584
* returns a valid status if drive unit is not installed in a
* library. ASC/ASCQ:0x82/0x00. May need to add other library types
* to this check, check scsi docs.
*
* If drive is not fully populated and there is an empty slot for the
* drive, we don't need to create a redundant drive_thread.
*/
avail_drives = count;
drv_tbl = malloc_wait(count, 2, 0);
(void) memset(drv_tbl, TRUE, count);
if (DT_IBM3584 == un->type)
if ((avail_drives =
(uint16_t)populate_drives(library, drv_tbl)) == 0) {
/*
* No drives installed, assum fully populated.
*/
DevLog(DL_ERR(5361));
avail_drives = count;
(void) memset(drv_tbl, TRUE, count);
} else if (avail_drives > count) {
avail_drives = count;
}
DevLog(DL_DETAIL(5362), avail_drives);
/* one for the drive, one for stage and one for the stage helper */
conlevel += (avail_drives * 3);
library->drive = (drive_state_t *)malloc_wait(
sizeof (drive_state_t), 5, 0);
library->index = library->drive;
(void) memset(library->drive, 0, sizeof (drive_state_t));
/*
* For each drive, build the drive state structure, put the init
* request on the list and start a thread with a new lwp.
*/
for (drive = library->drive, i = 0;
i < (int)count && avail_drives > 0; i++) {
if (drv_tbl[i] == FALSE) {
continue;
}
/* assign element number */
drive->element = start_element + i;
drive->library = library;
/* hold the lock until ready */
mutex_lock(&drive->mutex);
drive->new_slot = ROBOT_NO_SLOT;
drive->open_fd = -1;
drive->active_count = 1;
drive->first = (robo_event_t *)malloc_wait(
sizeof (robo_event_t), 5, 0);
(void) memset(drive->first, 0, sizeof (robo_event_t));
drive->first->type = EVENT_TYPE_INTERNAL;
drive->first->status.bits = REST_FREEMEM;
drive->first->request.internal.command = ROBOT_INTRL_INIT;
if (thr_create(NULL, MD_THR_STK, &drive_thread, (void *) drive,
(THR_NEW_LWP | THR_BOUND | THR_DETACHED),
&drive->thread)) {
DevLog(DL_SYSERR(5116));
drive->status.b.offline = TRUE;
drive->thread = (thread_t)- 1;
}
if (--avail_drives <= 0) {
break;
} else {
/* Allocate next entry */
drive->next = (drive_state_t *)malloc_wait(
sizeof (drive_state_t), 5, 0);
(void) memset(drive->next, 0, sizeof (drive_state_t));
drive->next->previous = drive; /* set back link */
drive = drive->next;
}
}
drive->next = NULL; /* no next drive */
library->drive->previous = NULL; /* no previous drive */
free(drv_tbl);
/* Allocate transport tables */
BE16toH(&pg1d->first_tport, &start_element);
BE16toH(&pg1d->num_tport, &count);
library->range.transport_lower = start_element;
library->range.transport_count = count;
library->range.transport_upper = start_element + count - 1;
library->range.default_transport = 0;
library->page1f = pg1f;
conlevel += count;
library->transports =
(xport_state_t *)malloc_wait(sizeof (xport_state_t), 5, 0);
(void) memset(library->transports, 0, sizeof (xport_state_t));
for (xport = library->transports, i = 0; i < (int)count; i++) {
/* assign element number */
xport->element = start_element + i;
xport->library = library;
mutex_lock(&xport->mutex);
/* start only one transport thread */
if (i == 0) {
xport->first =
(robo_event_t *)malloc_wait(
sizeof (robo_event_t), 5, 0);
(void) memset(xport->first, 0, sizeof (robo_event_t));
xport->first->type = EVENT_TYPE_INTERNAL;
xport->first->status.bits = REST_FREEMEM;
xport->first->request.internal.command =
ROBOT_INTRL_INIT;
xport->active_count = 1;
if (thr_create(NULL, SM_THR_STK,
&transport_thread, (void *) xport,
(THR_NEW_LWP | THR_BOUND | THR_DETACHED),
&xport->thread)) {
DevLog(DL_SYSERR(5117));
xport->thread = (thread_t)- 1;
}
}
/* Allocate next entry */
if (i != (count - 1)) {
xport->next = (xport_state_t *)malloc_wait(
sizeof (xport_state_t), 5, 0);
(void) memset(xport->next, 0, sizeof (xport_state_t));
xport->next->previous = xport; /* set back link */
xport = xport->next;
}
}
/* for the metrum d-360 the last transport is used with import export */
xport->next = NULL; /* no next transport */
library->transports->previous = NULL;
/* Allocate mailbox (import/export) tables */
BE16toH(&pg1d->first_mail, &start_element);
BE16toH(&pg1d->num_mail, &count);
library->range.ie_lower = start_element;
library->range.ie_count = count;
if (count != 0)
library->range.ie_upper = start_element + count - 1;
else
library->range.ie_upper = 0;
conlevel += 1; /* only one import/export thread */
library->import = (iport_state_t *)malloc_wait(
sizeof (iport_state_t), 5, 0);
(void) memset(library->import, 0, sizeof (iport_state_t));
/* store the transport used in import/export for the metrum D-360 */
if (un->type == DT_METD28)
library->import->xport = xport;
for (import = library->import, i = 0; i < (int)count; i++) {
SANITY_CHECK(import != (iport_state_t *)0);
/* assign element number */
import->element = start_element + i;
import->library = library;
mutex_lock(&import->mutex);
/* Create only one mailbox thread */
if (i == 0) {
import->active_count = 1;
import->first = (robo_event_t *)malloc_wait(
sizeof (robo_event_t), 5, 0);
(void) memset(import->first, 0, sizeof (robo_event_t));
import->first->type = EVENT_TYPE_INTERNAL;
import->first->status.bits = REST_FREEMEM;
import->first->request.internal.command =
ROBOT_INTRL_INIT;
if (thr_create(NULL, SM_THR_STK,
&import_thread, (void *) import,
(THR_DETACHED | THR_BOUND | THR_NEW_LWP),
&import->thread)) {
DevLog(DL_SYSERR(5118));
import->thread = (thread_t)- 1;
}
}
if (i != (count - 1)) { /* Allocate next entry */
import->next = (iport_state_t *)malloc_wait(
sizeof (iport_state_t), 5, 0);
(void) memset(import->next, 0, sizeof (iport_state_t));
/* set back link */
import->next->previous = import;
import = import->next;
}
}
import->next = NULL; /* no next mailbox */
SANITY_CHECK(library->import != (iport_state_t *)0);
library->import->previous = NULL;
/* allocate the audit table if needed */
BE16toH(&pg1d->first_stor, &start_element);
BE16toH(&pg1d->num_stor, &count);
library->range.storage_lower = start_element;
library->range.storage_count = count;
library->range.storage_upper = start_element + count - 1;
/* add for the import/export door slots */
if (un->type == DT_ACL452)
count += library->range.ie_count;
DevLog(DL_DETAIL(5220), library->range.drives_count,
library->range.transport_count, library->range.storage_count,
library->range.ie_count);
if (thr_setconcurrency(conlevel)) {
DevLog(DL_SYSERR(5058));
}
/*
* If the audit table is the wrong length (based on the number of
* storage elements returned by mode-sense) or the audit bit is set,
* the set up for an audit.
*/
if ((library->audit_tab_len == 0) || un->status.b.audit) {
int added_more_time = FALSE;
char *l_mess = un->dis_mes[DIS_MES_NORM];
/*
* Audit table does not exist or is the wrong length. This
* is generally a bad thing and will force an initialize
* element scsi command and an audit. Both of these take a
* long time.
*/
/* tell the outside world */
un->status.b.audit = TRUE;
memccpy(l_mess, catgets(catfd, SET, 9022,
"initializing elements"),
'\0', DIS_MES_LEN);
mutex_lock(&un->io_mutex);
retry = 2;
do {
/*
* Allow 16 seconds for each storage element and 30
* seconds of slop.
*/
(void) memset(sense, 0, sizeof (sam_extended_sense_t));
if ((err = scsi_cmd(library->open_fd, un,
SCMD_INIT_ELEMENT_STATUS,
(count << 4) + 30)) < 0) {
TAPEALERT_SKEY(library->open_fd, un);
GENERIC_SCSI_ERROR_PROCESSING(un,
library->scsi_err_tab, 0,
err, added_more_time, retry,
/* code for DOWN_EQU */
down_library(library, SAM_STATE_CHANGE);
mutex_unlock(&un->io_mutex);
return (-1);
/* MACRO for cstyle */,
/* code for ILLREQ */
mutex_unlock(&un->io_mutex);
return (-1);
/* MACRO for cstyle */,
/*
* move - move from one element to another
*
* entry -
* library - library_t *
* event - robo_event_t *
*/
int
move(
library_t *library,
robo_event_t *event)
{
dev_ent_t *un;
int err = -1, retry, timeout;
char *l_mess = library->un->dis_mes[DIS_MES_NORM];
char *MES_9079 =
catgets(catfd, SET, 9079, "move from %s to %s %s");
char *mess, *src_mess, *des_mess, *i_mess;
robot_internal_t *cmd = &event->request.internal;
int added_more_time = FALSE;
sam_extended_sense_t *sense = (sam_extended_sense_t *)
SHM_REF_ADDR(library->un->sense);
int movmed_err;
un = library->un;
src_mess = element_string(element_type(library, cmd->source));
des_mess = element_string(element_type(library, cmd->destination1));
if (cmd->flags.b.invert1)
i_mess = catgets(catfd, SET, 9084, "invert");
else
i_mess = "";
mess = (char *)malloc_wait(strlen(MES_9079) + strlen(src_mess) +
strlen(des_mess) + strlen(i_mess) + 10, 4, 0);
sprintf(mess, MES_9079, src_mess, des_mess, i_mess);
memccpy(l_mess, mess, '\0', DIS_MES_LEN);
free(mess);
DevLog(DL_DETAIL(5057),
cmd->source, cmd->flags.b.invert1 ? "invert" : "asis",
cmd->destination1);
/*
* A programming note from DocStore states that you should
* allow up to 4 minutes for a move. This is to allow
* for recovery and retry by the robot. If other robots need
* different time outs, this is the place to put um.
*/
switch (library->un->type) {
case DT_DLT2700:
timeout = 300;
break;
case DT_DOCSTOR:
timeout = 4 * 60;
break;
case DT_METD28:
/* FALLTHROUGH */
case DT_METD360:
/* FALLTHROUGH */
case DT_SPECLOG:
/* FALLTHROUGH */
case DT_ATL1500:
/* FALLTHROUGH */
case DT_ODI_NEO:
/* FALLTHROUGH */
case DT_QUANTUMC4:
/* FALLTHROUGH */
case DT_STK97XX:
/* FALLTHROUGH */
case DT_FJNMXX:
/* FALLTHROUGH */
case DT_SL3000:
/* FALLTHROUGH */
case DT_SLPYTHON:
timeout = 10 * 60;
break;
default:
timeout = 5 * 60;
break;
}
mutex_lock(&library->un->io_mutex);
retry = 2;
do {
time_t start;
TAPEALERT(library->open_fd, library->un);
memset(sense, 0, sizeof (sam_extended_sense_t));
start = time(NULL);
movmed_err = scsi_cmd(library->open_fd, library->un,
SCMD_MOVE_MEDIUM, timeout,
cmd->transport, cmd->source, cmd->destination1,
(cmd->flags.b.invert1 ? 1 : 0));
TAPEALERT(library->open_fd, library->un);
if (movmed_err < 0) {
DevLog(DL_TIME(5177), cmd->source,
cmd->flags.b.invert1 ? "invert" : "asis",
cmd->destination1, time(NULL) - start);
GENERIC_SCSI_ERROR_PROCESSING(library->un,
library->scsi_err_tab, 0,
err, added_more_time, retry,
/* code for DOWN_EQU */
if (!cmd->flags.b.noerror) {
err = DOWN_EQU;
if (sense->es_add_code == 0x40 &&
sense->es_qual_code == 0x02) {
move_drive_error(library, cmd->source,
cmd->destination1, &err);
} else {
down_library(library, SAM_STATE_CHANGE);
}
retry = 1;
/* MACRO for cstyle */
}
break;
/* MACRO for cstyle */,
void CMomentumPlayer::DisableAutoBhop()
{
m_bAutoBhop = false;
DevLog("Disabled autobhop\n");
}
void CMomentumPlayer::EnableAutoBhop()
{
m_bAutoBhop = true;
DevLog("Enabled autobhop\n");
}
/*
* Main thread. Sits on the message queue and waits for something to do.
*/
void *
transport_thread(
void *vxport)
{
int exit_status = 0, err;
robo_event_t *event;
xport_state_t *transport = (xport_state_t *)vxport;
int is_api = IS_GENERIC_API(transport->library->un->type);
dev_ent_t *un = transport->library->un;
mutex_lock(&transport->mutex); /* wait for go */
mutex_unlock(&transport->mutex);
for (;;) {
mutex_lock(&transport->list_mutex);
if (transport->active_count == 0)
cond_wait(&transport->list_condit,
&transport->list_mutex);
if (transport->active_count == 0) { /* check to make sure */
mutex_unlock(&transport->list_mutex);
continue;
}
event = transport->first;
transport->first = unlink_list(event);
transport->active_count--;
mutex_unlock(&transport->list_mutex);
ETRACE((LOG_NOTICE, "EvTr %#x(%#x) -",
event, (event->type == EVENT_TYPE_MESS) ?
event->request.message.command :
event->request.internal.command));
err = 0;
switch (event->type) {
case EVENT_TYPE_INTERNAL:
switch (event->request.internal.command) {
case ROBOT_INTRL_MOVE_MEDIA:
if (is_api == TRUE) {
err = EINVAL;
break;
} else {
if (un->state <= DEV_IDLE) {
err = move(transport->library,
event);
} else {
err = EINVAL;
}
}
break;
case ROBOT_INTRL_EXCH_MEDIA:
if (is_api == TRUE) {
err = EINVAL;
break;
} else {
if (un->state <= DEV_IDLE) {
err = exchange(
transport->library, event);
} else {
err = EINVAL;
}
}
break;
case ROBOT_INTRL_INIT:
init_transport(transport);
if (is_api == TRUE) {
disp_of_event(transport->library,
event, 0);
}
break;
case ROBOT_INTRL_SHUTDOWN:
transport->thread = (thread_t)- 1;
thr_exit(&exit_status);
break;
case ROBOT_INTRL_LOAD_MEDIA:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_load_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_FORCE_MEDIA:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_force_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_DISMOUNT_MEDIA:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_dismount_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_VIEW_DATABASE:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_view_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_DRIVE_ACCESS:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_drive_access_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_QUERY_DRIVE:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_query_drive_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_GET_SIDE_INFO:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_getsideinfo_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
default:
err = EINVAL;
break;
}
break;
case EVENT_TYPE_MESS:
if (event->request.message.magic != MESSAGE_MAGIC) {
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:bad magic: %s:%d.",
__FILE__, __LINE__);
break;
}
switch (event->request.message.command) {
default:
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:msq_bad: %s:%d.",
__FILE__, __LINE__);
err = EINVAL;
break;
}
default:
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:event_bad: %s:%d.",
__FILE__, __LINE__);
err = EINVAL;
break;
}
if (is_api == FALSE) {
disp_of_event(transport->library, event, err);
} else if (err) {
/* call disp_of_event only if an error on grau */
if (err < 0)
err = errno;
disp_of_event(transport->library, event, err);
}
}
}
/*
* -- tapealert - tapealert log sense page 0x2e processing
* Process media changer or tape drive request for tapealert log sense
* page 0x2e. An active tapealert never interferes with data
* transfers. Active tapealert flags are written to the device log and
* real-time notification is by a posted tapealert sysevent. See
* www.t10.org SSC-2 and SMC-2 for additional tapealert information.
*/
int /* 0 successful */
tapealert(
char *src_fn, /* source filename */
int src_ln, /* source file line number */
int fd, /* device file descriptor */
dev_ent_t *un, /* device */
uchar_t *logpage, /* existing tapealert log sense page */
int logpage_len) /* existing tapealert log sense page length */
{
#define CLEAN_NOW 0x80000
#define CLEAN_PERIODIC 0x100000
#define EXPIRED_CLEANING_MEDIA 0x200000
#define INVALID_CLEANING_MEDIA 0x400000
#define STK_CLEAN_REQUESTED 0x800000
int rtn = 1;
uchar_t *page;
uchar_t *log_param;
#define PAGE_LEN 256
uchar_t tmp_page [PAGE_LEN];
int resid;
int i;
int j;
int page_len;
int param_len;
int param_code;
int add_page_len;
sam_extended_sense_t *sense;
sam_extended_sense_t saved_sense;
uchar_t saved_cdb [16];
#define FLAGS_LEN 64
int flags_len;
uint64_t flags;
uchar_t val;
int save_errno = errno;
uint64_t seq_no = 0;
int supported;
int enabled;
int init_query;
int required;
int requested;
int expired;
int invalid;
supported = un->tapealert & TAPEALERT_SUPPORTED;
enabled = un->tapealert & TAPEALERT_ENABLED;
init_query = un->tapealert & TAPEALERT_INIT_QUERY;
if (!(supported && (enabled || init_query))) {
return (0);
}
/*
* get device sense pointer.
*/
sense = (sam_extended_sense_t *)SHM_REF_ADDR(un->sense);
/*
* Second, process tapealert log sense page.
*/
if (logpage == NULL || logpage_len < 4) {
/* save callers previous cdb and sense */
memcpy(saved_cdb, un->cdb, SAM_CDB_LENGTH);
memcpy(&saved_sense, sense, sizeof (sam_extended_sense_t));
if (scsi_cmd(fd, un, SCMD_LOG_SENSE, 0, tmp_page, 0,
0x2e, 0, PAGE_LEN, &resid) < 0) {
DevLog(DL_DEBUG(12002), sense->es_key,
sense->es_add_code, sense->es_qual_code);
memcpy(un->cdb, saved_cdb, SAM_CDB_LENGTH);
memcpy(sense, &saved_sense,
sizeof (sam_extended_sense_t));
goto cleanup;
}
/* restore callers previous cdb and sense */
memcpy(un->cdb, saved_cdb, SAM_CDB_LENGTH);
memcpy(sense, &saved_sense, sizeof (sam_extended_sense_t));
page = tmp_page;
page_len = PAGE_LEN - resid;
} else {
page = logpage;
page_len = logpage_len;
}
if (page_len < 4) {
DevLog(DL_DEBUG(12003), page_len);
goto cleanup;
}
if (page [0] != 0x2e) {
DevLog(DL_DEBUG(12004), page [0]);
goto cleanup;
}
add_page_len = (page [2] << 8) | page [3];
add_page_len &= 0xffff;
log_param = page + 4;
flags = 0;
flags_len = 0;
for (i = 0, j = 0; i < FLAGS_LEN && j < add_page_len; i++, j += 5) {
param_code = (log_param [j] << 8) | log_param [j + 1];
if (param_code != (i + 1)) {
if (flags != 0) break;
goto cleanup;
}
param_len = log_param [j + 3];
param_len &= 0xff;
if (param_len == 1) {
val = log_param [j + 4];
if (i < 64 && val != 0) {
flags |= ((uint64_t)1 << i);
}
} else {
/*
* vendor unique flag length value, quit
* processing flags
*/
break;
}
/*
* increment number of valid TapeAlert flags
* contained in the 64 bit wide flags variable
*/
flags_len++;
}
/* check for in-active or already seen */
if (flags == 0 || (flags == un->tapealert_flags &&
strcmp(un->tapealert_vsn, un->vsn) == 0)) {
rtn = 0;
goto cleanup;
}
/* build active flags filter by vsn */
if (strcmp(un->tapealert_vsn, un->vsn) == 0) {
/* check for already seen */
if ((flags & ~un->tapealert_flags) == 0) {
rtn = 0;
goto cleanup;
}
/* current vsn, add active flag(s) to filter */
un->tapealert_flags |= flags;
} else {
/* new vsn, initialize flags filter */
un->tapealert_flags = flags;
}
strcpy(un->tapealert_vsn, un->vsn);
/*
* send tapealert sysevent
*/
rtn = tapealert_sysevent(src_fn, src_ln, un, flags_len, flags, &seq_no);
/*
* log active flags
*
* seq_no is zero when sysevent not sent.
*/
if (strlen(un->vsn) > 0) {
DevLog(DL_ALL(12007), un->version, un->eq, un->scsi_type,
seq_no, flags_len, flags, un->vsn);
} else {
DevLog(DL_ALL(12006), un->version, un->eq, un->scsi_type,
seq_no, flags_len, flags);
}
if ((un->tapeclean & TAPECLEAN_AUTOCLEAN) &&
(un->tapeclean & TAPECLEAN_LOGSENSE)) {
required = (flags & CLEAN_NOW) ? 1 : 0;
requested = (flags & CLEAN_PERIODIC) ? 1 : 0;
expired = (flags & EXPIRED_CLEANING_MEDIA) ? 1 : 0;
invalid = (flags & INVALID_CLEANING_MEDIA) ? 1 : 0;
if (un->equ_type == DT_9840 ||
un->equ_type == DT_9940 || un->equ_type == DT_TITAN) {
requested = (flags & STK_CLEAN_REQUESTED) ? 1 : 0;
}
/* Map active TapeAlert flags onto SAM-FS status. */
tapeclean_active(un, required, requested, expired, invalid);
}
cleanup:
/*
* restore callers errno state
*/
errno = save_errno;
return (rtn);
}
/* --- tapealert_sysevent - send a tapealert sysevent to n event handlers */
static int /* 0 successful */
tapealert_sysevent(
char *src_fn, /* source filename */
int src_ln, /* source file line number */
dev_ent_t *un, /* device */
int flags_len, /* num valid tapealert flags */
uint64_t flags, /* tapealert flags */
uint64_t *seq_no) /* sysevent sequence number */
{
int rtn = 1;
time_t tm;
nvlist_t *attr_list = NULL;
sysevent_id_t eid;
boolean_t free_attr_list = B_FALSE;
char *str;
*seq_no = 0;
/*
* build and send sysevent with active tapealert flags
*/
if (nvlist_alloc(&attr_list, 0, 0)) {
DevLog(DL_DEBUG(12008), "alloc", strerror(errno));
goto done;
}
free_attr_list = B_TRUE;
#ifdef DEBUG
if (nvlist_add_string(attr_list, TAPEALERT_SRC_FILE, src_fn)) {
DevLog(DL_DEBUG(12008), TAPEALERT_SRC_FILE, strerror(errno));
goto done;
}
if (nvlist_add_int32(attr_list, TAPEALERT_SRC_LINE, src_ln)) {
DevLog(DL_DEBUG(12008), TAPEALERT_SRC_LINE, strerror(errno));
goto done;
}
#endif /* DEBUG */
if (nvlist_add_string(attr_list, TAPEALERT_VENDOR,
(char *)un->vendor_id)) {
DevLog(DL_DEBUG(12008), TAPEALERT_VENDOR, strerror(errno));
goto done;
}
if (nvlist_add_string(attr_list, TAPEALERT_PRODUCT,
(char *)un->product_id)) {
DevLog(DL_DEBUG(12008), TAPEALERT_PRODUCT, strerror(errno));
goto done;
}
if (nvlist_add_string(attr_list, TAPEALERT_USN, (char *)un->serial)) {
DevLog(DL_DEBUG(12008), TAPEALERT_USN, strerror(errno));
goto done;
}
if (nvlist_add_string(attr_list, TAPEALERT_REV, (char *)un->revision)) {
DevLog(DL_DEBUG(12008), TAPEALERT_REV, strerror(errno));
goto done;
}
time(&tm);
if (nvlist_add_int32(attr_list, TAPEALERT_TOD, tm)) {
DevLog(DL_DEBUG(12008), TAPEALERT_TOD, strerror(errno));
goto done;
}
if (nvlist_add_int16(attr_list, TAPEALERT_EQ_ORD, un->eq)) {
DevLog(DL_DEBUG(12008), TAPEALERT_EQ_ORD, strerror(errno));
goto done;
}
if (nvlist_add_string(attr_list, TAPEALERT_NAME, un->name)) {
DevLog(DL_DEBUG(12008), TAPEALERT_NAME, strerror(errno));
goto done;
}
if (nvlist_add_byte(attr_list, TAPEALERT_VERSION, un->version)) {
DevLog(DL_DEBUG(12008), TAPEALERT_VERSION, strerror(errno));
goto done;
}
if (nvlist_add_byte(attr_list, TAPEALERT_INQ_TYPE, un->scsi_type)) {
DevLog(DL_DEBUG(12008), TAPEALERT_INQ_TYPE, strerror(errno));
goto done;
}
if (strlen(str = (char *)un->set) < 1) {
str = TAPEALERT_EMPTY_STR;
}
if (nvlist_add_string(attr_list, TAPEALERT_SET, str)) {
DevLog(DL_DEBUG(12008), TAPEALERT_SET, strerror(errno));
goto done;
}
if (nvlist_add_int16(attr_list, TAPEALERT_FSEQ, un->fseq)) {
DevLog(DL_DEBUG(12008), TAPEALERT_FSEQ, strerror(errno));
goto done;
}
if (strlen(str = (char *)un->vsn) < 1) {
str = TAPEALERT_EMPTY_STR;
}
if (nvlist_add_string(attr_list, TAPEALERT_VSN, str)) {
DevLog(DL_DEBUG(12008), TAPEALERT_VSN, strerror(errno));
goto done;
}
if (nvlist_add_int16(attr_list, TAPEALERT_FLAGS_LEN, flags_len)) {
DevLog(DL_DEBUG(12008), TAPEALERT_FLAGS_LEN, strerror(errno));
goto done;
}
if (nvlist_add_uint64(attr_list, TAPEALERT_FLAGS, flags)) {
DevLog(DL_DEBUG(12008), TAPEALERT_FLAGS,
strerror(errno));
goto done;
}
/* class, subclass, vendor, publisher, attribute list, event id */
if (sysevent_post_event(TAPEALERT_SE_CLASS, TAPEALERT_SE_SUBCLASS,
TAPEALERT_SE_VENDOR, TAPEALERT_SE_PUBLISHER, attr_list, &eid)
!= 0) {
DevLog(DL_DEBUG(12008), TAPEALERT_SE_PUBLISHER,
strerror(errno));
goto done;
}
*seq_no = eid.eid_seq;
/*
* tapealert sysevent successfully sent.
*/
rtn = 0;
done:
if (free_attr_list == B_TRUE) {
nvlist_free(attr_list);
}
return (rtn);
}
int main(int argc, char *argv[ ]){
ClearPrints();
chdir(CombineStrings("/home/", GetUser()));
DelFile(output_log);
DebugLog("--- Begin Android Dev Tools ARGS");
for(tick = 1; tick < argc; tick++) DebugLog(CombineStrings("ARG: ", argv[tick]));
DebugLog("");
DebugLog("--- Begin Android Dev Tools");
CmdOut("aDev_adb devices > tmp.txt");
if(IsFileEmpty("tmp.txt")){
ClearPrints();
PrintText("--- Proprietary Files Not Found! ---");
PrintText("Run: \'aDev config\'");
LineSkip();
exit(-1);
}
DelFile("tmp.txt");
if(argc <= 1){
PrintText("--- Invalid parameters! ---");
PrintText("Run: \'aDev --help\'");
LineSkip();
exit(-1);
}
for(tick = 1; tick < argc; tick++){
if(IsStringEmpty(argv[tick])) continue;
if(CompareStrings(argv[tick], "--help") || CompareStrings(argv[tick], "-h")){
PrintHelp();
exit(0);
}
if(CompareStrings(argv[tick], "--version") || CompareStrings(argv[tick], "-v")){
PrintVersion();
exit(0);
}
else if(CompareStrings(argv[tick], "test")){
PrintText("aDev was properly installed, enjoy!");
LineSkip();
exit(0);
}
else if(CompareStrings(argv[tick], "logcat")){
DevLog(1);
exit(0);
}
else if(CompareStrings(argv[tick], "dmesg")){
DevLog(2);
exit(0);
}
else if(CompareStrings(argv[tick], "kmsg")){
DevLog(3);
exit(0);
}
else if(CompareStrings(argv[tick], "screenshot")){
ScreenShot();
exit(0);
}
else if(CompareStrings(argv[tick], "info")){
Info();
exit(0);
}
else if(CompareStrings(argv[tick], "adb")){
text = "aDev_adb ";
for(tick2 = 1; tick2 < argc; tick2++) if(!CompareStrings(argv[tick2], "adb")) text = CombineStrings(text, CombineStrings(argv[tick2], " "));
CmdOut(text);
exit(0);
}
else if(CompareStrings(argv[tick], "fastboot")){
text = "aDev_fastboot ";
for(tick2 = 1; tick2 < argc; tick2++) if(!CompareStrings(argv[tick2], "fastboot")) text = CombineStrings(text, CombineStrings(argv[tick2], " "));
CmdOut(text);
exit(0);
}
else{
for(tick2 = (argc - 1); tick2 < 0; tick2--){
if(!IsValidArg(argv[tick2])) break;
if(tick2 == 1) quit();
}
if(IsValidArg(argv[tick2])) tick2--;
if(IsValidArg(argv[tick2])) quit();
PrintText(CombineStrings("Unknown Parameter: ", argv[tick2]));
quit();
}
}
return 0;
}
