void main()
{
unsigned addr;
// Initialize hardware
discover();
// Initialize screen
d_screen = getdevice(screenId);
addr = d_screen->address;
asm("SET B, [%vram]");
interrupt(addr);
// Initialize keyboard
d_keyboard = getdevice(keyboardId);
// Initialize clock
d_clock = getdevice(clockId);
updateclockfreq();
print("Booted!\n");
kernel();
}
_CODE_ACCESS int rename(const char *old_name, const char *new_name)
{
_DEVICE *old_dev, *new_dev;
int result;
/*------------------------------------------------------------------------*/
/* CRITICAL REGION PROTECTS _device[] ACCESS THAT OCCURS IN getdevice() */
/* (see file header comment for more on mutex and data coherence). */
/*------------------------------------------------------------------------*/
__TI_resource_lock(__TI_LOCK_DEVICE_TBL);
old_dev = getdevice(&old_name);
new_dev = getdevice(&new_name);
/*------------------------------------------------------------------------*/
/* IF THE DEVICES ARE NOT THE SAME, RENAME WOULD REQUIRE A FILE COPY. */
/*------------------------------------------------------------------------*/
if (old_dev != new_dev)
{
__TI_data_synch_INV(&_device, sizeof(_device));
__TI_resource_unlock(__TI_LOCK_DEVICE_TBL);
return -1;
}
/*------------------------------------------------------------------------*/
/* CALL FUNCTION FROM DEVICE TABLE TO PERFORM RENAME FOR THIS DEVICE/FILE */
/*------------------------------------------------------------------------*/
result = (*(old_dev->RENAME)) (old_name, new_name);
__TI_data_synch_INV(&_device, sizeof(_device));
__TI_resource_unlock(__TI_LOCK_DEVICE_TBL);
return result;
}
void getfilestats(file_t *file)
{
file->size = filesize(file->d_name);
file->inode = getinode(file->d_name);
file->device = getdevice(file->d_name);
file->mtime = getmtime(file->d_name);
}
void* tfileworker(void* argument)
{
GlobalDate* date = GlobalDate::create();
vector<Bridge*> bdg_v;
if(!getdevice(&bdg_v))
return NULL;
while(1)
{
date->Io->out("please input \"/sourse-path to /dst-path\"\n");
string command = date->Io->in();
if(command == "q")
pthread_exit(NULL);
string src,dst;
if (!TaskClass::rsolvepath(command,src,dst))
{
date->Io->out("path err, input again\n");
continue;
}
EventClass* repork = new EventClass;
TaskClass * shelltask = new TaskClass(T_TFILE, command, &bdg_v,repork);
shelltask->setwrbk(sendshell_cb);
shelltask->setrdbk(tfile_cb);
if(shelltask->rgstask() == -1)
{
delete repork;
delete shelltask;
}
repork->run();
}
}
int is_hardlink(filetree_t *checktree, file_t *file)
{
file_t *dupe;
ino_t inode;
dev_t device;
inode = getinode(file->d_name);
device = getdevice(file->d_name);
if ((inode == checktree->file->inode) &&
(device == checktree->file->device))
return 1;
if (checktree->file->hasdupes)
{
dupe = checktree->file->duplicates;
do {
if ((inode == dupe->inode) &&
(device == dupe->device))
return 1;
dupe = dupe->duplicates;
} while (dupe != NULL);
}
return 0;
}
int relink(char *oldfile, char *newfile)
{
dev_t od;
dev_t nd;
ino_t oi;
ino_t ni;
od = getdevice(oldfile);
oi = getinode(oldfile);
if (link(oldfile, newfile) != 0)
return 0;
/* make sure we're working with the right file (the one we created) */
nd = getdevice(newfile);
ni = getinode(newfile);
if (nd != od || oi != ni)
return 0; /* file is not what we expected */
return 1;
}
static
int config(struct audio_config *config)
{
unsigned int bitdepth;
int format = 0;
AuDeviceID device;
AuElement elements[2];
bitdepth = config->precision & ~7;
if (bitdepth == 0 || bitdepth > 16)
bitdepth = 16;
switch (config->precision = bitdepth) {
case 8:
format = AuFormatLinearSigned8;
audio_pcm = audio_pcm_s8;
break;
case 16:
# if defined(WORDS_BIGENDIAN)
format = AuFormatLinearSigned16MSB;
audio_pcm = audio_pcm_s16be;
# else
format = AuFormatLinearSigned16LSB;
audio_pcm = audio_pcm_s16le;
# endif
break;
}
device = getdevice(server, &config->channels);
if (device == AuNone) {
audio_error = _("could not find an output device");
return -1;
}
AuMakeElementImportClient(&elements[0], config->speed, format,
config->channels, AuTrue,
config->speed * 2, config->speed, 0, 0);
AuMakeElementExportDevice(&elements[1], 0, device, config->speed,
AuUnlimitedSamples, 0, 0);
AuSetElements(server, flow, AuTrue, 2, elements, 0);
AuRegisterEventHandler(server, AuEventHandlerIDMask, 0, flow,
eventhandler, 0);
AuStartFlow(server, flow, 0);
return 0;
}
void* shellworker(void * argument)
{
GlobalDate* date = GlobalDate::create();
vector<Bridge*> bdg_v;
if(!getdevice(&bdg_v))
return NULL;
date->Io->out("please input shell command !\n");
string command = date->Io->in();
EventClass* repork = new EventClass;
TaskClass * shelltask = new TaskClass(T_SHELL, command, &bdg_v,repork);
shelltask->setwrbk(sendshell_cb);
shelltask->setrdbk(reportshell_cb);
shelltask->rgstask();
repork->run();
}
_CODE_ACCESS int unlink(const char *path)
{
_DEVICE *dev;
int result;
/*------------------------------------------------------------------------*/
/* GET A DEVICE AND CALL FUNCTION FROM DEVICE TABLE TO PERFORM UNLINK */
/* FOR THIS DEVICE/FILE */
/*------------------------------------------------------------------------*/
/* CRITICAL REGION PROTECTS _device[] ACCESS THAT OCCURS IN getdevice() */
/* (see file header comment for more on mutex and data coherence). */
/*------------------------------------------------------------------------*/
__TI_resource_lock(__TI_LOCK_DEVICE_TBL);
dev = getdevice(&path);
result = (*(dev->UNLINK)) (path);
__TI_data_synch_INV(&_device, sizeof(_device));
__TI_resource_unlock(__TI_LOCK_DEVICE_TBL);
return result;
}
_CODE_ACCESS int open(const char *path, unsigned flags, int mode)
{
static _DATA_ACCESS int stream_init = 0;
struct stream_info *ptr;
_DEVICE *dev;
int dev_fd;
int llv_fd;
/*-------------------------------------------------------------------------*/
/* CRITICAL REGION PROTECTS ACCESS TO _stream[] (see file header comment). */
/*-------------------------------------------------------------------------*/
__TI_resource_lock(__TI_LOCK_STREAM_TBL);
/*-------------------------------------------------------------------------*/
/* INITIALIZE STREAM TABLE FIRST TIME AROUND */
/*-------------------------------------------------------------------------*/
if (!stream_init)
{
for (stream_init = 1, ptr = &_stream[3]; ptr != &_stream[_NSTREAM];
(ptr++)->dev = NULL);
__TI_data_synch_WBINV(&stream_init, sizeof(stream_init));
}
/*-------------------------------------------------------------------------*/
/* GET THE NEXT AVAILABLE FILE DESCRIPTOR - RETURN -1 IF NONE AVAILABLE */
/*-------------------------------------------------------------------------*/
for (ptr = &_stream[3]; ptr != &_stream[_NSTREAM] && ptr->dev; ++ptr);
if (ptr == &_stream[_NSTREAM])
{
__TI_data_synch_INV(&_stream, sizeof(_stream));
__TI_resource_unlock(__TI_LOCK_STREAM_TBL);
return -1;
}
llv_fd = ptr - &_stream[0];
/*------------------------------------------------------------------------*/
/* GET DEVICE AND PEFORM OPEN - SET STREAM TABLE ENTRY AND FLAGS */
/*------------------------------------------------------------------------*/
/* CRITICAL REGION PROTECTS _device[] ACCESS THAT OCCURS IN getdevice() */
/* (see file header comment for more on mutex and data coherence). */
/*------------------------------------------------------------------------*/
__TI_resource_lock(__TI_LOCK_DEVICE_TBL);
dev = getdevice(&path);
dev_fd = (dev->flags & _BUSY) ? -1 : (*(dev->OPEN))(path,flags,llv_fd);
if (dev_fd < 0)
{
__TI_data_synch_INV(&_stream, sizeof(_stream));
__TI_data_synch_INV(&_device, sizeof(_device));
__TI_resource_unlock(__TI_LOCK_DEVICE_TBL);
__TI_resource_unlock(__TI_LOCK_STREAM_TBL);
return dev_fd;
}
_stream[llv_fd].dev = dev;
_stream[llv_fd].dfd = dev_fd;
if (!(dev->flags & _MSA)) dev->flags |= _BUSY;
__TI_data_synch_WBINV(&_stream, sizeof(_stream));
__TI_data_synch_WBINV(&_device, sizeof(_device));
__TI_resource_unlock(__TI_LOCK_DEVICE_TBL);
__TI_resource_unlock(__TI_LOCK_STREAM_TBL);
return llv_fd;
}
