int MUGIDFromName(
char *GName)
{
struct group *buf;
int tmpGID = 0;
const char *FName = "MUGIDFromName";
MDB(7,fSTRUCT) MLog("%s(%s)\n",
FName,
(GName != NULL) ? GName : "NULL");
if ((GName == NULL) || !strcmp(GName,NONE))
{
return(-1);
}
errno = 0;
buf = getgrnam(GName);
if (buf == NULL)
{
MDB(3,fSTRUCT) MLog("ALERT: error looking up group '%s' - %s (errno:%d)\n",
GName,
strerror(errno),
errno);
/* look for GID??? format */
if (!strncmp(GName,"GID",strlen("GID")))
{
return(atoi(GName + strlen("GID")));
}
/* check to see if GName is the GID number itself (group names cannot start
* with a number) */
tmpGID = (int)strtol(GName,NULL,10);
if (tmpGID != 0)
{
return(tmpGID);
}
return(-1);
}
return(buf->gr_gid);
} /* END MUGIDFromName() */
int MCacheRemoveVM(
char *Name)
{
if (MCache == NULL)
{
return(FAILURE);
}
if (MUStrIsEmpty(Name))
{
MDB(3,fSCHED) MLog("INFO: Blank name given. Cannot remove from cache.\n");
return(FAILURE);
}
pthread_rwlock_wrlock(&MCache->VMLock);
MUHTRemove(&MCache->VMs,Name,&MVMTransitionFree);
if (DBWRITE)
{
MMongoInterface::MMongoDeleteO(Name,mxoxVM);
}
pthread_rwlock_unlock(&MCache->VMLock);
return(SUCCESS);
}
int MCacheWriteVM(
mtransvm_t *VM) /* I */
{
int rc;
const char *FName = "MCacheWriteVM";
MDB(8,fSCHED) MLog("%s(%s)\n",
FName,
(VM != NULL) ? VM->VMID : NULL);
if (MCache == NULL)
{
return(FAILURE);
}
pthread_rwlock_wrlock(&MCache->VMLock);
rc = MUHTAdd(&MCache->VMs,VM->VMID,(void *)VM,NULL,&MVMTransitionFree);
if (DBWRITE)
{
MMongoInterface::MTransOToMongo(VM,mxoxVM);
}
pthread_rwlock_unlock(&MCache->VMLock);
return(rc);
} /* END MCacheWriteVM() */
int MCacheRemoveJob(
char *JName)
{
if (MUStrIsEmpty(JName))
{
MDB(3,fSCHED) MLog("INFO: Blank name given. Cannot remove from cache.\n");
return(FAILURE);
}
pthread_rwlock_wrlock(&MCache->JobLock);
MUHTRemove(&MCache->Jobs,JName,&MJobTransitionFree);
if (DBWRITE)
{
MMongoInterface::MMongoDeleteO(JName,mxoJob);
}
pthread_rwlock_unlock(&MCache->JobLock);
return(SUCCESS);
}
int MCacheWriteNode(
mtransnode_t *N)
{
int rc;
const char *FName = "MCacheWriteNode";
MDB(7,fTRANS) MLog("%s(%s)\n",
FName,
(MUStrIsEmpty(N->Name)) ? "NULL" : N->Name);
if (MCache == NULL)
{
return(FAILURE);
}
/* Obtain the write lock and write the object */
pthread_rwlock_wrlock(&MCache->NodeLock);
rc = MUHTAdd(&MCache->Nodes,N->Name,(void*)N,NULL,&MNodeTransitionFree);
if (DBWRITE)
{
MMongoInterface::MTransOToMongo(N,mxoNode);
}
pthread_rwlock_unlock(&MCache->NodeLock);
return(rc);
} /* END MCacheWriteNode() */
int MCacheReadVMs(
marray_t *VMArray, /* O */
marray_t *ConstraintList) /* I */
{
mhashiter_t HTIter;
char *VMID;
mtransvm_t *VM;
if (MCache == NULL)
{
return(FAILURE);
}
MUHTIterInit(&HTIter);
pthread_rwlock_rdlock(&MCache->VMLock);
while (MUHTIterate(&MCache->VMs,&VMID,(void **)&VM,NULL,&HTIter) == SUCCESS)
{
if (MVMTransitionMatchesConstraints(VM,ConstraintList))
{
MUArrayListAppendPtr(VMArray,VM);
}
else
{
MDB(8,fSCHED) MLog("INFO: VM %s does not meet constraints.\n",VM->VMID);
}
} /* END while (MUHTIterate) */
pthread_rwlock_unlock(&MCache->VMLock);
return(SUCCESS);
} /* END MCacheReadVMs() */
int MCacheReadTriggers(
marray_t *TArray, /* O */
marray_t *ConstraintList) /* I */
{
mhashiter_t HTIter;
char *TrigID;
mtranstrig_t *T;
if (MCache == NULL)
{
return(FAILURE);
}
MUHTIterInit(&HTIter);
pthread_rwlock_rdlock(&MCache->TriggerLock);
while (MUHTIterate(&MCache->Triggers,&TrigID,(void **)&T,NULL,&HTIter) == SUCCESS)
{
if (MTrigTransitionMatchesConstraints(T,ConstraintList))
{
MUArrayListAppendPtr(TArray,T);
}
else
{
MDB(8,fSCHED) MLog("INFO: Trigger %s does not meet constraints.\n",T->TrigID);
}
} /* END while (MUHTIterate) */
pthread_rwlock_unlock(&MCache->TriggerLock);
return(SUCCESS);
} /* END MCacheReadTriggers() */
int MCacheReadJobs(
marray_t *JArray,
marray_t *ConstraintList)
{
mhashiter_t HTIter;
char *Name;
mtransjob_t *J;
if (MCache == NULL)
{
return(FAILURE);
}
MUHTIterInit(&HTIter);
pthread_rwlock_rdlock(&MCache->JobLock);
while (MUHTIterate(&MCache->Jobs,&Name,(void **)&J,NULL,&HTIter) == SUCCESS)
{
if (MJobTransitionMatchesConstraints(J,ConstraintList))
{
MUArrayListAppendPtr(JArray,J);
}
else
{
MDB(8,fSCHED) MLog("INFO: Job %s does not meet constraints.\n",J->Name);
}
} /* END while (MUHTIterate) */
pthread_rwlock_unlock(&MCache->JobLock);
return(SUCCESS);
} /* END MCacheReadJobs() */
int MCacheReadRsvs(
marray_t *RArray,
marray_t *ConstraintList)
{
mhashiter_t HTIter;
char *Name;
mtransrsv_t *R;
if (MCache == NULL)
{
return(FAILURE);
}
MUHTIterInit(&HTIter);
pthread_rwlock_rdlock(&MCache->RsvLock);
while (MUHTIterate(&MCache->Rsvs,&Name,(void **)&R,NULL,&HTIter) == SUCCESS)
{
if (MRsvTransitionMatchesConstraints(R,ConstraintList))
{
MUArrayListAppendPtr(RArray,R);
}
else
{
MDB(8,fSCHED) MLog("INFO: Reservation %s does not meet constraints.\n",R->Name);
}
} /* END while (MUHTIterate) */
pthread_rwlock_unlock(&MCache->RsvLock);
return(SUCCESS);
} /* END MCacheReadRsvs() */
int MDAGDestroy(
marray_t *DList) /* I (modified) */
{
int index;
mdepend_t **DArray;
mdepend_t *tmpD;
const char *FName = "MDAGDestroy";
MDB(9,fALL) MLog("%s(DList)\n",
FName);
if (DList == NULL)
{
return(FAILURE);
}
DArray = (mdepend_t **)DList->Array;
for (index = 0;index < DList->NumItems;index++)
{
tmpD = DArray[index];
MUFree(&tmpD->Value);
MUFree(&tmpD->SValue);
MUFree((char **)&DArray[index]);
}
MUArrayListFree(DList);
return(SUCCESS);
} /* END MDAGDestroy() */
int MSysDequeueSocket(
msocket_t **S) /* O */
{
if (S == NULL)
{
return(FAILURE);
}
if (MUDLListSize(MSocketQueue) == 0)
{
/* queue is empty */
return(FAILURE);
}
MUMutexLock(&MSocketQueueMutex);
*S = (msocket_t *)MUDLListRemoveFirst(MSocketQueue);
MSched.TransactionCount--;
MUMutexUnlock(&MSocketQueueMutex);
MUGetMS(NULL,(long *)&(*S)->ProcessTime);
MDB(7,fSOCK) MLog("INFO: socket %d being serviced after %lu milli-sec wait\n",
(*S)->sd,
(*S)->ProcessTime - (*S)->CreateTime);
return(SUCCESS);
} /* END MSysDequeueSocket() */
int MWikiSDUpdate(
char *AString, /* I */
msdata_t *SD, /* I (modified) */
mrm_t *R) /* I */
{
char *ptr;
char *tail;
char SDAttr[MMAX_BUFFER];
char EMsg[MMAX_LINE];
char tmpLine[MMAX_LINE];
const char *FName = "MWikiSDUpdate";
MDB(2,fWIKI) MLog("%s(AString,SD,%s)\n",
FName,
(R != NULL) ? R->Name : "NULL");
if ((SD == NULL) || (AString == NULL))
{
return(FAILURE);
}
ptr = AString;
/* FORMAT: <FIELD>=<VALUE> [<FIELD>=<VALUE>]... */
while (ptr[0] != '\0')
{
if ((tail = MUStrChr(ptr,' ')) != NULL)
{
strncpy(SDAttr,ptr,MIN(MMAX_BUFFER - 1,tail - ptr));
SDAttr[tail - ptr] = '\0';
}
else
{
MUStrCpy(SDAttr,ptr,MMAX_BUFFER);
}
if (MWikiSDUpdateAttr(SDAttr,SD,R,EMsg) == FAILURE)
{
snprintf(tmpLine,sizeof(tmpLine),"info corrupt for staging-data '%s -> %s' - %s",
SD->SrcLocation,
SD->DstLocation,
EMsg);
MMBAdd(&R->MB,tmpLine,NULL,mmbtNONE,0,0,NULL);
}
if (tail == NULL)
break;
ptr = tail + 1;
} /* END while ((tail = MUStrChr(ptr,';')) != NULL) */
return(SUCCESS);
} /* END MWikiSDUpdate() */
int MLocalCheckFairnessPolicy(
mjob_t *J,
long StartTime,
char *Message)
{
const char *FName = "MLocalCheckFairnessPolicy";
MDB(6,fSCHED) MLog("%s(%s,%ld,Message)\n",
FName,
(J != NULL) ? J->Name : "NULL",
(unsigned long)StartTime);
/*
if (ContribJobLengthFairnessPolicy(J,StartTime,Message) == FAILURE)
{
return(FAILURE);
}
*/
/*
if (ContribASCBackgroundJobPolicy(J,StartTime,Message) == FAILURE)
{
return(FAILURE);
}
*/
/* all local policies passed */
return(SUCCESS);
} /* END MLocalFairnessPolicy() */
int MDAGCopy(
marray_t *DList,
marray_t *SList)
{
mdepend_t *tmpS;
const char *FName = "MDAGCopy";
MDB(5,fALL) MLog("%s(DList,SList)\n",
FName);
if ((SList == NULL) || (DList == NULL))
{
return(FAILURE);
}
if (DList->Array != NULL)
{
MUArrayListFree(DList);
}
if (SList->Array == NULL)
{
/* nothing to copy */
return(SUCCESS);
}
MUArrayListCreate(DList,SList->ElementSize,SList->NumItems);
tmpS = ((mdepend_t **)SList->Array)[0];
if (tmpS == NULL)
{
/* nothing to copy */
return(SUCCESS);
}
while (tmpS != NULL)
{
MDAGSetAnd(DList,tmpS->Type,tmpS->Value,tmpS->SValue,&tmpS->BM);
tmpS = tmpS->NextAnd;
}
tmpS = ((mdepend_t **)SList->Array)[0]->NextOr;
while (tmpS != NULL)
{
MDAGSetOr(DList,tmpS->Type,tmpS->Value,NULL);
tmpS = tmpS->NextOr;
}
return(SUCCESS);
} /* END MDAGCopy */
int MDAGCreate(
marray_t *DList, /* I */
mdepend_t **DP) /* O (modified) */
{
mdepend_t *NewD = NULL;
const char *FName = "MDAGCreate";
MDB(5,fALL) MLog("%s(DList,DP)\n",
FName);
if (DP != NULL)
{
*DP = NULL;
}
if ((DList == NULL) || (DP == NULL))
{
return(FAILURE);
}
NewD = (mdepend_t *)MUCalloc(1,sizeof(mdepend_t));
if (NewD == NULL)
{
MDB(1,fALL) MLog("ALERT: could not allocate new dependency\n");
return(FAILURE);
}
NewD->Satisfied = MBNOTSET;
if (MUArrayListAppendPtr(DList,NewD) == FAILURE)
{
return(FAILURE);
}
*DP = NewD;
NewD->Index = DList->NumItems-1;
return(SUCCESS);
} /* END MDAGCreate() */
int MMBCopyAll(
mmb_t **DstHead, /* O (modified/alloc) */
mmb_t *SrcHead) /* I */
{
mmb_t *mptr;
mmb_t *MB;
const char *FName = "MMBCopyAll";
MDB(7,fSTRUCT) MLog("%s(DstHead,SrcHead)\n",
FName);
if (DstHead == NULL)
{
return(FAILURE);
}
if (SrcHead == NULL)
{
return(SUCCESS);
}
for (mptr = SrcHead;mptr != NULL;mptr = mptr->Next)
{
if (MMBAdd(
DstHead,
mptr->Data,
mptr->Owner,
mptr->Type,
mptr->ExpireTime,
mptr->Priority,
&MB) == FAILURE)
{
continue;
}
MB->Count = mptr->Count;
MB->IsPrivate = mptr->IsPrivate;
MB->CTime = mptr->CTime;
if (mptr->Label != NULL)
MUStrDup(&MB->Label,mptr->Label);
if (mptr->Source != NULL)
MUStrDup(&MB->Source,mptr->Source);
} /* END for (mptr) */
return(SUCCESS);
} /* END MMBCopyAll() */
int MDAGSetAnd(
marray_t *DP, /* I */
enum MDependEnum DType, /* I */
char *Value, /* I (optional) */
char *SValue, /* I (optional) */
mbitmap_t *FlagBM) /* I */
{
mdepend_t *tmpD;
mdepend_t *NewD;
const char *FName = "MDAGSetAnd";
MDB(5,fALL) MLog("%s(DP,%s,%s,%s)\n",
FName,
MDependType[DType],
(Value != NULL) ? Value : "NULL",
(SValue != NULL) ? SValue : "NULL");
if ((DP == NULL) ||
(DP->Array == NULL))
return(FAILURE);
tmpD = ((mdepend_t **)DP->Array)[0];
if (MDAGCreate(DP,&NewD) == FAILURE)
{
return(FAILURE);
}
if (tmpD != NULL)
{
while (tmpD->NextAnd != NULL)
{
tmpD = tmpD->NextAnd;
}
tmpD->NextAnd = NewD;
}
NewD->Type = DType;
MUStrDup(&NewD->SValue,SValue);
MUStrDup(&NewD->Value,Value);
bmcopy(&NewD->BM,FlagBM);
return(SUCCESS);
} /* END MDAGSetAnd() */
int MUMutexUnlock(
mmutex_t *Mutex) /* I */
{
#ifdef MTHREADSAFE
if (pthread_mutex_unlock(Mutex) != 0)
{
MDB(0,fCORE) MLog("ALERT: cannot unlock mutex!\n");
return(FAILURE);
}
#endif /* MTHREADSAFE */
return(SUCCESS);
} /* END MUMutexUnlock() */
int MDAGSetOr(
marray_t *DList,
enum MDependEnum DType,
char *Value,
char *SValue)
{
mdepend_t *tmpD;
mdepend_t *NewD;
const char *FName = "MDAGSetOr";
MDB(5,fALL) MLog("%s(DList,%s,%s,%s)\n",
FName,
MDependType[DType],
(Value != NULL) ? Value : "NULL",
(SValue != NULL) ? SValue : "NULL");
if ((DList == NULL) ||
(DList->Array == NULL))
return(FAILURE);
tmpD = (mdepend_t *)MUArrayListGetPtr(DList,0);
if (MDAGCreate(DList,&NewD) == FAILURE)
{
return(FAILURE);
}
if (tmpD != NULL)
{
while (tmpD->NextOr != NULL)
{
tmpD = tmpD->NextOr;
}
tmpD->NextOr = NewD;
}
NewD->Type = DType;
MUStrDup(&NewD->SValue,SValue);
MUStrDup(&NewD->Value,Value);
return(SUCCESS);
} /* END MDAGSetOr() */
int MRsvAdjustTime(
long Delta) /* I (time change in seconds) */
{
rsv_iter RTI;
int nindex;
mnode_t *N;
mrsv_t *R;
mre_t *RE;
const char *FName = "MRsvAdjustTime";
MDB(4,fSTRUCT) MLog("%s(%ld)\n",
FName,
Delta);
MRsvIterInit(&RTI);
while (MRsvTableIterate(&RTI,&R) == SUCCESS)
{
R->StartTime = MIN(R->StartTime + Delta,MMAX_TIME);
R->EndTime = MIN(R->EndTime + Delta,MMAX_TIME);
}
for (nindex = 0;nindex < MSched.M[mxoNode];nindex++)
{
N = MNode[nindex];
if ((N == NULL) || (N->Name[0] == '\0'))
break;
if (N->Name[0] == '\1')
continue;
for (RE = N->RE;RE != NULL;MREGetNext(RE,&RE))
{
RE->Time = MIN(RE->Time + Delta,MMAX_TIME);
} /* END for (MREGetNext) */
} /* END for (nindex) */
return(SUCCESS);
} /* END MRsvAdjustTime() */
int MUMutexLock(
mmutex_t *Mutex) /* I */
{
#ifdef MTHREADSAFE
if (pthread_mutex_lock(Mutex) != 0)
{
/* NOTE: this can result in infinite recursion as MLog() calls MUMutexLock() */
MDB(0,fCORE) MLog("ALERT: cannot lock mutex!\n");
return(FAILURE);
}
#endif /* MTHREADSAFE */
return(SUCCESS);
} /* END MULockMutex() */
int MMBRemoveMessage(
mmb_t **Head,
const char *Msg,
enum MMBTypeEnum MType)
{
int Index;
const char *FName = "MMBRemoveMessage";
MDB(7,fSTRUCT) MLog("%s(Head,%.32s...,%s)\n",
FName,
(Msg != NULL) ? Msg : "",
(MType <= mmbtLAST) ? MMBType[MType] : "???");
if ((Head == NULL) || ((Msg == NULL) && (MType == mmbtNONE)))
{
return(SUCCESS);
}
if (Msg != NULL)
{
/* locate messages which match string */
if (MMBGetIndex(*Head,NULL,Msg,mmbtNONE,&Index,NULL) == SUCCESS)
{
/* remove specified message */
MMBRemove(Index,Head);
}
}
else
{
/* locate messages which match type */
while (MMBGetIndex(*Head,NULL,NULL,MType,&Index,NULL) == SUCCESS)
MMBRemove(Index,Head);
}
return(SUCCESS);
} /* END MMBRemoveMessage() */
static int trix_set_wss_port(struct address_info *hw_config)
{
unsigned char addr_bits;
if (trix_read(0x15) != 0x71) /* No ASIC signature */
{
MDB(printk(KERN_ERR "No AudioTrix ASIC signature found\n"));
return 0;
}
/*
* Reset some registers.
*/
trix_write(0x13, 0);
trix_write(0x14, 0);
/*
* Configure the ASIC to place the codec to the proper I/O location
*/
switch (hw_config->io_base)
{
case 0x530:
addr_bits = 0;
break;
case 0x604:
addr_bits = 1;
break;
case 0xE80:
addr_bits = 2;
break;
case 0xF40:
addr_bits = 3;
break;
default:
return 0;
}
trix_write(0x19, (trix_read(0x19) & 0x03) | addr_bits);
return 1;
}
int MSysAddSocketToQueue(
msocket_t *S)
{
MUMutexLock(&MSocketQueueMutex);
/* place S into queue */
MDB(7,fSOCK) MLog("INFO: socket '%d' being enqueued\n",
S->sd);
MUDLListAppend(MSocketQueue,S);
MSched.TransactionCount++;
MSched.HistMaxTransactionCount = MAX(MSched.TransactionCount,MSched.HistMaxTransactionCount);
MUMutexUnlock(&MSocketQueueMutex);
return(SUCCESS);
} /* END MSysAddSocketToQueue() */
int MLocalJobCheckNRes(
const mjob_t *J,
const mnode_t *N,
long StartTime)
{
int rc = SUCCESS;
const char *FName = "MLocalJobCheckNRes";
MDB(8,fSCHED) MLog("%s(%s,%s,%ld)\n",
FName,
J->Name,
N->Name,
StartTime);
/*
rc = ContribAussieJobCheckNRes(J,N,StartTime);
*/
return(rc);
} /* END MLocalJobCheckNRes */
int MTrigValidate(
mtrig_t *T) /* I */
{
const char *FName = "MTrigValidate";
MDB(3,fRM) MLog("%s(T)\n",
FName);
if (T == NULL)
{
return(FAILURE);
}
if (T->AType == mtatNONE)
{
return(FAILURE);
}
if (T->EType == mttNONE)
{
return(FAILURE);
}
/* requires an action fro all types except cancel, preempt, and reserve */
if ((T->Action == NULL) &&
(T->AType != mtatCancel) &&
(T->AType != mtatJobPreempt) &&
(T->AType != mtatReserve))
{
return(FAILURE);
}
return(SUCCESS);
} /* END MTrigValidate() */
int MCacheWriteVC(
mtransvc_t *VC) /* I */
{
int rc;
const char *FName = "MCacheWriteVC";
MDB(8,fSCHED) MLog("%s(%s)\n",
FName,
(VC != NULL) ? VC->Name : NULL);
if (MCache == NULL)
{
return(FAILURE);
}
pthread_rwlock_wrlock(&MCache->VCLock);
if (VC->IsDeleteRequest == FALSE)
rc = MUHTAdd(&MCache->VCs,VC->Name,(void *)VC,NULL,&MVCTransitionFree);
else
{
rc = MUHTRemove(&MCache->VCs,VC->Name,&MVCTransitionFree);
/* We freed the existing transvc from the hash table, but not the one
that was just passed in */
MVCTransitionFree((void **)&VC);
}
pthread_rwlock_unlock(&MCache->VCLock);
return(rc);
} /* END MCacheWriteVC() */
static int __init init_trix_wss(struct address_info *hw_config)
{
static unsigned char dma_bits[4] = {
1, 2, 0, 3
};
struct resource *ports;
int config_port = hw_config->io_base + 0;
int dma1 = hw_config->dma, dma2 = hw_config->dma2;
int old_num_mixers = num_mixers;
u8 config, bits;
int ret;
switch(hw_config->irq) {
case 7:
bits = 8;
break;
case 9:
bits = 0x10;
break;
case 10:
bits = 0x18;
break;
case 11:
bits = 0x20;
break;
default:
printk(KERN_ERR "AudioTrix: Bad WSS IRQ %d\n", hw_config->irq);
return 0;
}
switch (dma1) {
case 0:
case 1:
case 3:
break;
default:
printk(KERN_ERR "AudioTrix: Bad WSS DMA %d\n", dma1);
return 0;
}
switch (dma2) {
case -1:
case 0:
case 1:
case 3:
break;
default:
printk(KERN_ERR "AudioTrix: Bad capture DMA %d\n", dma2);
return 0;
}
/*
* Check if the IO port returns valid signature. The original MS Sound
* system returns 0x04 while some cards (AudioTrix Pro for example)
* return 0x00.
*/
ports = request_region(hw_config->io_base + 4, 4, "ad1848");
if (!ports) {
printk(KERN_ERR "AudioTrix: MSS I/O port conflict (%x)\n", hw_config->io_base);
return 0;
}
if (!request_region(hw_config->io_base, 4, "MSS config")) {
printk(KERN_ERR "AudioTrix: MSS I/O port conflict (%x)\n", hw_config->io_base);
release_region(hw_config->io_base + 4, 4);
return 0;
}
if (!trix_set_wss_port(hw_config))
goto fail;
config = inb(hw_config->io_base + 3);
if ((config & 0x3f) != 0x00)
{
MDB(printk(KERN_ERR "No MSS signature detected on port 0x%x\n", hw_config->io_base));
goto fail;
}
/*
* Check that DMA0 is not in use with a 8 bit board.
*/
if (dma1 == 0 && config & 0x80)
{
printk(KERN_ERR "AudioTrix: Can't use DMA0 with a 8 bit card slot\n");
goto fail;
}
if (hw_config->irq > 9 && config & 0x80)
{
printk(KERN_ERR "AudioTrix: Can't use IRQ%d with a 8 bit card slot\n", hw_config->irq);
goto fail;
}
ret = ad1848_detect(ports, NULL, hw_config->osp);
if (!ret)
goto fail;
if (joystick==1)
trix_write(0x15, 0x80);
/*
* Set the IRQ and DMA addresses.
*/
outb((bits | 0x40), config_port);
if (dma2 == -1 || dma2 == dma1)
{
bits |= dma_bits[dma1];
dma2 = dma1;
}
else
{
unsigned char tmp;
tmp = trix_read(0x13) & ~30;
trix_write(0x13, tmp | 0x80 | (dma1 << 4));
tmp = trix_read(0x14) & ~30;
trix_write(0x14, tmp | 0x80 | (dma2 << 4));
}
outb((bits), config_port); /* Write IRQ+DMA setup */
hw_config->slots[0] = ad1848_init("AudioTrix Pro", ports,
hw_config->irq,
dma1,
dma2,
0,
hw_config->osp,
THIS_MODULE);
if (num_mixers > old_num_mixers) /* Mixer got installed */
{
AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_LINE); /* Line in */
AD1848_REROUTE(SOUND_MIXER_LINE2, SOUND_MIXER_CD);
AD1848_REROUTE(SOUND_MIXER_LINE3, SOUND_MIXER_SYNTH); /* OPL4 */
AD1848_REROUTE(SOUND_MIXER_SPEAKER, SOUND_MIXER_ALTPCM); /* SB */
}
return 1;
fail:
release_region(hw_config->io_base, 4);
release_region(hw_config->io_base + 4, 4);
return 0;
}
int MUUIDFromName(
char *Name, /* I */
char *HomeDir, /* O (optional,minsize=MMAX_LINE) */
char *EMsg) /* O (optional,minzise=MMAX_LINE) */
{
#define UTILUIDHEADER "UID"
struct passwd *bufptr = NULL;
struct passwd buf;
char pwbuf[MMAX_BUFFER];
#ifndef MNOREENTRANT
int rc = 0;
#endif /* !MNOREENTRANT */
const char *FName = "MUUIDFromName";
MDB(10,fSTRUCT) MLog("%s(%s,HomeDir,EMsg)\n",
FName,
(Name != NULL) ? Name : "NULL");
if (EMsg != NULL)
EMsg[0] = '\0';
if (HomeDir != NULL)
HomeDir[0] = '\0';
if ((Name == NULL) ||
!strcmp(Name,NONE) ||
!strcmp(Name,ALL) ||
!strcmp(Name,"ALL"))
{
if (EMsg != NULL)
sprintf(EMsg,"user name '%s' is invalid",
(Name != NULL) ? Name : "");
return(-1);
}
#ifndef MNOREENTRANT
/* getpwnam_r() will return positive value on FAILURE */
rc = getpwnam_r(Name,&buf,pwbuf,sizeof(pwbuf),&bufptr);
if ((rc != 0) || (bufptr == NULL))
{
/* look for UID??? format */
if (!strncmp(Name,UTILUIDHEADER,strlen(UTILUIDHEADER)))
{
return(atoi(Name + strlen(UTILUIDHEADER)));
}
if (EMsg != NULL)
snprintf(EMsg,MMAX_LINE,"cannot lookup user '%s' - errno=%d %s",
Name,
errno,
strerror(errno));
MDB(3,fSTRUCT) MLog("cannot lookup user '%s' - errno=%d %s\n",
Name,
errno,
strerror(errno));
return(-1);
}
#else
bufptr = getpwnam(Name);
if (bufptr == NULL)
{
/* look for UID??? format */
if (!strncmp(Name,UTILUIDHEADER,strlen(UTILUIDHEADER)))
{
return(atoi(Name + strlen(UTILUIDHEADER)));
}
if (EMsg != NULL)
snprintf(EMsg,MMAX_LINE,"cannot lookup user '%s' - errno=%d %s",
Name,
errno,
strerror(errno));
MDB(3,fSTRUCT) MLog("cannot lookup user '%s' - errno=%d %s\n",
Name,
errno,
strerror(errno));
return(-1);
}
#endif /* !MNOREENTRANT */
if (HomeDir != NULL)
{
MUStrCpy(HomeDir,bufptr->pw_dir,MMAX_LINE);
MDB(7,fSTRUCT) MLog("setting user %s's home dir to '%s'\n",
(Name != NULL) ? Name : "NULL",
HomeDir);
}
return(bufptr->pw_uid);
} /* END MUUIDFromName() */
char *MUUIDToName(
int UID, /* I */
char *NameBuf) /* O */
{
struct passwd *bufptr = NULL;
struct passwd buf;
char pwbuf[MMAX_BUFFER];
#ifndef MNOREENTRANT
int rc = 0;
#endif /* !MNOREENTRANT */
const char *FName = "MUUIDToName";
MDB(10,fSTRUCT) MLog("%s(%d,NameBuf)\n",
FName,
UID);
if (NameBuf == NULL)
{
return(NULL);
}
if (UID == -1)
{
strcpy(NameBuf,NONE);
return(NameBuf);
}
pwbuf[0] = '\0';
errno = 0;
/* getpwuid_r() will return positive value on FAILURE */
#ifndef MNOREENTRANT
rc = getpwuid_r(UID,&buf,pwbuf,sizeof(pwbuf),&bufptr);
if ((rc != 0) || (bufptr == NULL))
{
snprintf(NameBuf,MMAX_NAME,"UID%d",
UID);
}
else
{
MUStrCpy(NameBuf,bufptr->pw_name,MMAX_NAME);
}
#else
bufptr = getpwuid(UID);
if (bufptr == NULL)
{
sprintf(NameBuf,"UID%d",
UID);
}
else
{
strcpy(NameBuf,bufptr->pw_name);
}
#endif /* !MNOREENTRANT */
return(NameBuf);
} /* END MUUIDToName() */
