/*
* struct fs32_flushbuf_parms {
* unsigned short flag;
* unsigned short hVPB;
* };
*/
int FS32ENTRY fs32_flushbuf(struct fs32_flushbuf_parms *parms)
{
int rc;
struct super_block *sb;
if (trace_FS_FLUSHBUF)
{
kernel_printf("FS_FLUSHBUF - flag = %d, hVPB = 0x%0X", (int)(parms->flag), (int)(parms->hVPB));
}
if (Read_Write)
{
sb = getvolume(parms->hVPB);
if ((sb) && (sb->s_magic_internal == SUPER_MAGIC))
{
if (sb->s_status == VOL_STATUS_MOUNTED)
{
kernel_printf("\tmedia is present");
switch (parms->flag)
{
case FLUSH_RETAIN:
case FLUSH_DISCARD:
sync_buffers(sb->s_dev, 1);
if ((sb->s_op) && (sb->s_op->write_super))
sb->s_op->write_super(sb);
sync_inodes(sb->s_dev);
sync_buffers(sb->s_dev, 1);
rc = NO_ERROR;
break;
default:
rc = ERROR_INVALID_PARAMETER;
break;
}
}
else
{
rc = NO_ERROR;
}
}
else
{
rc = ERROR_INVALID_PARAMETER;
}
}
else
{
rc = NO_ERROR;
}
if (trace_FS_FLUSHBUF)
{
kernel_printf("FS_FLUSHBUF - flag = %d, hVPB = 0x%0X, rc = %d", (int)(parms->flag), (int)(parms->hVPB), rc);
}
return rc;
}
int main(int argc, char* argv[]) {
char *status;
char volume[20];
char *datetime;
char bat[20] = "";
int laptop = 0;
char hostname[30];
gethostname(hostname, 30);
printf("%s\n", hostname);
if (strcmp(hostname, "johan-laptop") == 0){
laptop = 1;
printf("This is a laptop\n");
}
else {
printf("This is not a laptop\n");
}
snd_mixer_t *handle;
snd_mixer_open(&handle, 0);
snd_mixer_attach(handle, "default");
const char* vol_ch = "Master";
snd_mixer_selem_register(handle, NULL, NULL);
snd_mixer_load(handle);
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(stderr, "Cannot open display.\n");
return 1;
}
if((status = malloc(200)) == NULL)
exit(1);
for (;;usleep(1000000)) {
datetime = getdatetime();
//volume = getcmd("$HOME/Scripts/volume\\ get.sh");
sprintf(volume, "%.0f%", getvolume(handle, vol_ch));
if (laptop){
sprintf(bat, " Bat: %.0f% |", getbattery());
}
snprintf(status, 200, "Vol: %s% |%s %s ", volume, bat, datetime );
free(datetime);
setstatus(status);
}
free(status);
XCloseDisplay(dpy);
return 0;
}
int main(void) {
char *status;
float mem;
int bat0;
char *datetime;
char *address;
char battext[6];
char *volume;
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(stderr, "Cannot open display.\n");
return 1;
}
status = xmalloc(200);
for (;;sleep(1)) {
datetime = getdatetime();
mem = getmeminfo();
bat0 = getbattery();
address = getaddress();
volume = getvolume();
if (ischarging())
strcpy(battext, "ac:");
else {
if (bat0 > 50)
strcpy(battext, "bat:");
else if (bat0 < 20)
strcpy(battext, "bat:");
else
strcpy(battext, "bat:");
}
snprintf(status, 200,
"|%s|mem:%0.0f%%|%s%d%%|vol:%s|%s|",
address, mem, battext, bat0, volume, datetime);
free(datetime);
free(address);
free(volume);
setstatus(status);
}
free(status);
XCloseDisplay(dpy);
return 0;
}
int main(void) {
Display *dpy;
char *temp;
char *status;
char *tmny;
char *batt;
char *wifi;
char *volume;
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(stderr, "dwmstatus: cannot open display.\n");
return 1;
}
for (;;sleep(1)) {
wifi = getsignalstrength();
batt = getbattery();
volume = getvolume();
temp = gettemperature("/sys/class/hwmon/hwmon0/temp1_input");
tmny = mktimes("%a %d %b %H:%M:%S", tzny);
/* status = smprintf("\x8D | \x8F | \x90 | \x9D | \x81 | %s", tmny); */
/* charge | batt | vol | mute | wifi | time */
status = smprintf("%s | %s%s%s %s", temp, volume, batt, wifi, tmny);
XStoreName(dpy, DefaultRootWindow(dpy), status);
XSync(dpy, False);
free(tmny);
free(batt);
free(wifi);
free(volume);
free(status);
}
XCloseDisplay(dpy);
return 0;
}
void MTInstrumentInstance::sendevents(int nevents,MTIEvent **events)
{
int x,y;
double next,tmp_vol,b,b1,b2;
float tmp_panx,tmp_pany,tmp_panz;
MTInstrument &cparent = *(MTInstrument*)parent;
bool first = true;
for (x=0;x<nevents;x++){
MTIEvent *cevent = events[x];
MTINoteEvent *nevent = (MTINoteEvent*)cevent;
MTIParamEvent *pevent = (MTIParamEvent*)cevent;
if (cevent){
switch (cevent->type){
case MTIE_NOTE:
nextevent = cpos;
if (nevent->note==0){
flags |= MTIIF_NOTEOFF;
if ((cparent.env[0].flags & EF_ENABLED)==0){
flags |= MTIIF_NOTECUT;
tvol = mvol = 0.0;
if (osc[0]) osc[0]->setvolume(0.0,FAST_RAMP,0);
}
else{
for (y=0;y<8;y++){
if (envs[y].wait){
envs[y].wait = false;
envs[y].count = 0.0;
};
};
};
continue;
};
flags &= (~(MTIIF_NOTEOFF|MTIIF_NOTECUT|MTIIF_FADEOUT));
// Global parameters
if (nevent->flags & MTIEF_ISINS){ // Is there an instrument?
gvol = cparent.gvol*nevent->gvolume;
gpanx = pan_mul(nevent->gpanx,cparent.gpanx);
gpany = pan_mul(nevent->gpany,cparent.gpany);
gpanz = pan_mul(nevent->gpanz,cparent.gpanz);
mtmemzero(envs,sizeof(envs));
for (x=0;x<8;x++) envs[x].lenvp = 65535;
cvol = getvolume();
getpanning(&cpanx,&cpany,&cpanz);
lastpos = cpos;
fadepos = 0.0;
MTInstrument &ins = *((MTInstrument*)parent);
fadeout = ins.fadeout;
nna = ins.nna;
iflags = ins.flags;
};
note = nevent->note;
if (osc[0]) first = false;
if (nevent->flags & MTIEF_ISNOTE){ // Is there a note?
if (osc[0]){
first = true;
delete osc[0];
osc[0] = 0;
};
if ((note<12) || (note>106)) continue;
grp[0] = cparent.range[0][(int)note-12];
}
else{
if ((note<12) || (note>106)) continue;
grp[0] = cparent.range[0][(int)note-12];
};
if (!osc[0]){
if (cparent.grp[grp[0]].spl){
if (filter){
osc[0] = cparent.grp[grp[0]].spl->createinstance(track->noutputs,buffer,this);
}
else{
osc[0] = cparent.grp[grp[0]].spl->createinstance(track->noutputs,track->buffer,this);
};
};
};
// Set the oscillator parameters
if (osc[0]){
if (first){
osc[0]->setnote(note+(double)cparent.grp[grp[0]].pitch/128);
};
y = (int)note-12;
gvol *= cparent.grp[grp[0]].vol;
if (nevent->flags & MTIEF_ISINS){
if (nevent->volume>-1.0) mvol = nevent->volume;
else mvol = (float)cparent.range[1][y]/128;
if (nevent->panx>-2.0) mpanx = pan_mul(cparent.grp[grp[0]].panx,nevent->panx);
else mpanx = pan_mul(cparent.grp[grp[0]].panx,(float)((signed char)cparent.range[2][y])/127);
if (nevent->pany>-2.0) mpany = pan_mul(cparent.grp[grp[0]].pany,nevent->pany);
else mpany = pan_mul(cparent.grp[grp[0]].pany,(float)((signed char)cparent.range[3][y])/127);
if (nevent->panz>-2.0) mpanz = pan_mul(cparent.grp[grp[0]].panz,nevent->panz);
else mpanz = pan_mul(cparent.grp[grp[0]].panz,(float)((signed char)cparent.range[4][y])/127);
};
tvol = cvol*mvol;
tpanx = pan_mul(mpanx,cpanx);
tpany = pan_mul(mpany,cpany);
tpanz = pan_mul(mpanz,cpanz);
osc[0]->setvolume(gvol*tvol);
osc[0]->setpanning(pan_mul(gpanx,tpanx),pan_mul(gpany,tpany),pan_mul(gpanz,tpanz));
};
break;
case MTIE_KILL:
if (!osc[0]) return;
flags |= IIF_BACKGROUND;
switch (nna & 0xFF){
case NNA_NOTECUT:
flags |= MTIIF_NOTECUT;
tvol = mvol = 0.0;
osc[0]->setvolume(0.0,FAST_RAMP,0);
break;
case NNA_NOTEOFF:
flags |= MTIIF_NOTEOFF;
if ((cparent.env[0].flags & EF_ENABLED)==0){
flags |= MTIIF_NOTECUT;
tvol = mvol = 0.0;
osc[0]->setvolume(0.0,FAST_RAMP,0);
}
else{
for (y=0;y<8;y++){
if (envs[y].wait){
envs[y].wait = false;
envs[y].count = 0.0;
};
};
nextevent = cpos;
};
break;
case NNA_FADEOUT:
flags |= MTIIF_FADEOUT;
fadepos = cpos;
nextevent = cpos;
/*
tvol = mvol = 0.0;
osc[0]->setvolume(0.0,FAST_RAMP,0);
*/
break;
};
break;
case MTIE_RESET:
break;
case MTIE_PARAM:
if ((!osc[0]) || (flags & MTIIF_NOTECUT)) return;
y = 0;
if ((pevent->param==MTIP_VOLUME) || (pevent->param==MTIP_PANNING)){
b1 = module->samplestobeats(MIN_RAMP);
b2 = module->samplestobeats(MAX_RAMP);
b = nextevent-cpos;
if (b<b1){
y = 0;
b = 0.0;
}
else if (b>b2){
y = FAST_RAMP;
b = module->samplestobeats(FAST_RAMP);
}
else{
y = (int)module->beatstosamples(b);
};
next = cpos+b;
if (next<nextevent) nextevent = next;
};
switch (pevent->param){
case MTIP_VOLUME:
tmp_vol = getvolume(b);
if (pevent->flags & MTIEF_MUL) mvol *= pevent->dvalue1;
else if (pevent->flags & MTIEF_ADD) mvol += pevent->dvalue1;
else mvol = pevent->dvalue1;
if (mvol<0.0) mvol = 0.0;
else if ((mvol>1.0) && ((pevent->flags & MTIEF_DONTSATURATE)==0)) mvol = 1.0;
tvol = tmp_vol*mvol;
osc[0]->setvolume(gvol*tvol,y);
break;
case MTIP_PANNING:
getpanning(&tmp_panx,&tmp_pany,&tmp_panz,b);
if (pevent->flags & MTIEF_MUL){
pan_self_mul(mpanx,pevent->fvalue1);
pan_self_mul(mpany,pevent->fvalue2);
pan_self_mul(mpanz,pevent->fvalue3);
}
else if (pevent->flags & MTIEF_ADD){
mpanx += pevent->fvalue1;
mpany += pevent->fvalue2;
mpanz += pevent->fvalue3;
if (mpanx<-1.0) mpanx = -1.0;
else if (mpanx>1.0) mpanx = 1.0;
if (mpany<-1.0) mpany = -1.0;
else if (mpany>1.0) mpany = 1.0;
if (mpanz<-1.0) mpanz = -1.0;
else if (mpanz>1.0) mpanz = 1.0;
}
else{
mpanx = pevent->fvalue1;
mpany = pevent->fvalue2;
mpanz = pevent->fvalue3;
};
pan_self_mul(mpanx,cparent.grp[grp[0]].panx);
pan_self_mul(mpany,cparent.grp[grp[0]].pany);
pan_self_mul(mpanz,cparent.grp[grp[0]].panz);
tpanx = pan_mul(mpanx,tmp_panx);
tpany = pan_mul(mpany,tmp_pany);
tpanz = pan_mul(mpanz,tmp_panz);
osc[0]->setpanning(pan_mul(gpanx,tpanx),pan_mul(gpany,tpany),pan_mul(gpanz,tpanz),y);
break;
case MTIP_NOTE:
if (pevent->flags & MTIEF_MUL) note *= pevent->dvalue1;
else if (pevent->flags & MTIEF_ADD) note += pevent->dvalue1;
else note = pevent->dvalue1;
osc[0]->setnote(note);
break;
};
break;
};
};
};
}
void MTInstrumentInstance::processevents()
{
int x,l,lp,e;
double inc;
MTInstrument &cins = *(MTInstrument*)parent;
if (!osc[0]){
nextevent = -1.0;
return;
};
inc = cpos-lastpos;
if (inc>0.0){
for (x=0;x<8;x++){
IEnvelope &cenv = ((MTInstrument*)parent)->env[x];
EnvStatus &cs = envs[x];
if ((cenv.flags & EF_ENABLED) && (cenv.npoints)){
// If the envelope was active then increment the position
if (!cs.process) cs.pos += inc;
// If the envelope was not idle then decrement the counter until next point
if (!cs.wait) cs.count -= inc;
};
// Mark the envelope as not active (it'll be active later if there is something to do with it)
cs.process = false;
};
};
lastpos = cpos;
inc = 1000.0;
if ((flags & MTIIF_NOTECUT)==0){
for (x=0;x<8;x++){
IEnvelope &cenv = cins.env[x];
if ((cenv.flags & EF_ENABLED) && (cenv.npoints)){
EnvStatus &cs = envs[x];
/* if (x==0){
FLOG4("%f\t%f\t%d\t%d\t%f",cs.pos,cs.count,cs.envp,cs.lenvp);
FLOG1("%f"NL,cvol);
};*/
l = 0;
if (cs.count<=0.0){ // We reached a new point
lp = cs.lenvp;
cs.lenvp = cs.envp;
// Calculate the last point we can reach
e = cenv.npoints-1; // ...either the last point
if (cenv.flags & EF_LOOP) e = cenv.loope; // ...or the loop end
if ((cenv.flags & EF_SUSTAIN) && ((flags & MTIIF_NOTEOFF)==0) && (cenv.suste<e)) e = cenv.suste; // ...or the sustain loop end
if (e==0){ // First and only point
switch (x){
case 0:
if ((e==cenv.npoints-1) && (iflags & MTIF_FAE) && ((flags & MTIIF_FADEOUT)==0)){
if (((cenv.flags & EF_SUSTAIN)==0) || ((flags & MTIIF_NOTEOFF)!=0)){
flags |= MTIIF_FADEOUT;
fadepos = cpos;
};
};
cvol = cenv.points[cs.envp].y;
break;
case 1:
cpanx = cenv.points[cs.envp].y;
break;
case 3:
ccutoff = cenv.points[cs.envp].y;
break;
};
cs.wait = true;
cs.count = 1000.0;
l = -1;
}
else if (cs.envp<e){ // Not at the end
// cs.process = true;
if (lp==65535){ // First point
switch (x){
case 0:
cvol = cenv.points[0].y;
tvol = cvol*mvol;
osc[0]->setvolume(gvol*tvol);
break;
case 1:
cpanx = cenv.points[0].y;
tpanx = pan_mul(mpanx,cpanx);
osc[0]->setpanning(pan_mul(gpanx,tpanx));
break;
case 3:
ccutoff = cenv.points[0].y;
if (filter) filter->setparam(0,0,ccutoff*cins.cutoff);
break;
};
};
cs.count = cenv.points[cs.envp+1].x-cs.pos;
if (cs.count<inc){
inc = cs.count;
};
l = (int)module->beatstosamples(cs.count);
switch (x){
case 0:
cvol = cenv.points[cs.envp+1].y;
break;
case 1:
cpanx = cenv.points[cs.envp+1].y;
break;
case 3:
ccutoff = cenv.points[cs.envp+1].y;
break;
};
cs.envp++;
}
else{ // At the end -> check for loop / sustain
// cs.process = true;
if (((cenv.flags & EF_LOOP)==0) && (((cenv.flags & EF_SUSTAIN)==0) || (flags & MTIIF_NOTEOFF))){
if (x==0){
if (osc[0]->volume<VOLUME_THRESOLD) inc = -1.0;
else{
if ((iflags & MTIF_FAE) && ((flags & MTIIF_FADEOUT)==0)){
if (ai->recording) ai->debugpoint(module->beatstosamples(module->playstatus.pos),"FO");
flags |= MTIIF_FADEOUT;
fadepos = cpos;
};
};
};
cs.wait = true;
cs.count = 1000.0;
l = -1;
}
else{
lp = cs.envp;
if ((cenv.flags & EF_SUSTAIN) && ((flags & MTIIF_NOTEOFF)==0) && (cenv.suste<cenv.loope)){
cs.envp = cenv.susts;
cs.pos = cs.pos-cenv.points[cenv.suste].x+cenv.points[cenv.susts].x;
}
else if (cenv.flags & EF_LOOP){
cs.envp = cenv.loops;
cs.pos = cs.pos-cenv.points[cenv.loope].x+cenv.points[cenv.loops].x;
};
if (lp!=cs.envp){
l = FAST_RAMP;
cs.count = module->samplestobeats(l);
if (cs.count<inc) inc = cs.count;
switch (x){
case 0:
cvol = cenv.points[cs.envp].y;
break;
case 1:
cpanx = cenv.points[cs.envp].y;
break;
case 3:
ccutoff = cenv.points[cs.envp].y;
break;
};
cs.wait = false;
}
else{
cs.wait = true;
cs.count = 1000.0;
l = -1;
};
};
};
}
else{
l = (int)module->beatstosamples(cs.count);
if (cs.count<inc) inc = cs.count;
};
if (l>=0){
switch (x){
case 0:
tvol = cvol*mvol;
osc[0]->setvolume(gvol*tvol,l,0);
break;
case 1:
tpanx = pan_mul(mpanx,cpanx);
osc[0]->setpanning(pan_mul(gpanx,tpanx),pan_mul(gpany,tpany),pan_mul(gpanz,tpanz),l,0);
break;
case 3:
if (filter) filter->setparam(0,0,(int)(ccutoff*cins.cutoff),l);
break;
};
};
};
if ((x==0) && (flags & MTIIF_FADEOUT)){
if (inc<=0.0) continue;
/*
if (cfadeout==0.0){
inc = -1.0;
continue;
};
cvol = getvolume(0.0,false)*(1.0+fadeout*(cpos-fadepos+inc));
cfadeout = cvol;
if (cvol<0.0){
cvol = 0.0;
inc = -(cpos-fadepos+1.0/fadeout);
};
l = (int)module->beatstosamples(inc);
tvol = cvol*mvol;
osc[0]->setvolume(gvol*tvol,l,0);
*/
if (fadepos==0.0){
fadepos = cpos;
};
cvol = getvolume(inc);
if (cvol<0.0){
cvol = 0.0;
inc = -(cpos-fadepos+1.0/fadeout);
};
l = (int)module->beatstosamples(inc);
tvol = cvol*mvol;
osc[0]->setvolume(gvol*tvol,l,0);
};
};
};
// Filter
if ((filter) && (((cins.env[3].flags & EF_ENABLED)==0) || (cins.env[3].npoints==0))){
double bpt = 1/(double)cins.tpb;
if ((cins.attack==0) && (cpos>=(double)cins.attack*bpt)){
if ((inc==0) || (inc>bpt)) inc = bpt;
// if ((inc==0) || (inc>bpt*0.5)) inc = bpt*0.5;
l = (int)module->beatstosamples(inc);
double c = sqrt(1.0f/((1.0f+(float)cins.decay*0.5f)*(1+(cpos+inc)*cins.tpb-cins.attack)));
c = acos(1-c)/f2pi;
filter->setparam(0,0,(float)cins.cutoff*c,l);
};
};
if (inc>0.0){
nextevent += inc;
for (x=0;x<8;x++){
IEnvelope &cenv = ((MTInstrument*)parent)->env[x];
EnvStatus &cs = envs[x];
cs.process = cs.wait;
};
/*
for (x=0;x<8;x++){
IEnvelope &cenv = ((MTInstrument*)parent)->env[x];
EnvStatus &cs = envs[x];
if ((cenv.npoints) && (!cs.wait) && (cs.process)){
cs.pos += inc;
};
};
*/
}
else{
flags |= IIF_SLEEPING;
// nextevent = -1.0;
};
}
/*
* struct fs32_chdir_parms {
* unsigned short iCurDirEnd;
* PTR16 pDir;
* PTR16 pcdfsd;
* PTR16 pcdfsi;
* unsigned short flag;
* };
*/
int FS32ENTRY fs32_chdir(struct fs32_chdir_parms *parms)
{
char *pDir;
struct cdfsi32 *pcdfsi;
union cdfsd32 *pcdfsd;
int rc;
struct file *p_file;
struct super_block *sb;
int valid;
char *tmp;
struct inode *base;
switch (parms->flag)
{
case CD_EXPLICIT:
pcdfsi = VDHQueryLin(parms->pcdfsi);
pcdfsd = VDHQueryLin(parms->pcdfsd);
pDir = VDHQueryLin(parms->pDir);
if (trace_FS_CHDIR)
{
kernel_printf("FS_CHDIR( CD_EXPLICIT, %s )", pDir);
}
rc = ERROR_INVALID_PARAMETER;
if (parms->iCurDirEnd != CURDIREND_INVALID)
{
tmp = pDir + parms->iCurDirEnd;
if ((pcdfsd->u.p_file) && (pcdfsd->u.p_file->f_magic == FILE_MAGIC))
{
base = pcdfsd->u.p_file->f_inode;
if (base)
{
rc = NO_ERROR;
}
}
}
else
{
sb = getvolume(pcdfsi->cdi_hVPB);
if ((sb) && (sb->s_magic_internal == SUPER_MAGIC))
{
tmp = skip_drive(pDir);
base = sb->s_mounted;
if (base)
{
rc = NO_ERROR;
}
}
}
if (rc == NO_ERROR)
{
if ((p_file = open_by_name(base, tmp, OPENMODE_READONLY)) == 0)
{
rc = ERROR_PATH_NOT_FOUND;
}
else
{
if (!S_ISDIR(p_file->f_inode->i_mode))
{
kernel_printf("FS_CHDIR( %s ) Not a directory", pDir);
vfs_close(p_file);
rc = ERROR_ACCESS_DENIED;
}
else
{
pcdfsd->u.is_valid = 1;
pcdfsd->u.p_file = p_file;
rc = NO_ERROR;
}
}
}
break;
case CD_VERIFY:
pcdfsi = VDHQueryLin(parms->pcdfsi);
pcdfsd = VDHQueryLin(parms->pcdfsd);
if (trace_FS_CHDIR)
{
kernel_printf("FS_CHDIR : flag = CD_VERIFY hVPB=0x%04X", pcdfsi->cdi_hVPB);
}
//
// Gets the superblock from pcdfsi
//
sb = getvolume(pcdfsi->cdi_hVPB);
valid = 1;
if ((p_file = open_by_name(sb->s_mounted, skip_drive(pcdfsi->cdi_curdir), OPENMODE_READONLY)) == 0)
{
valid = 0;
}
else
{
if (!S_ISDIR(p_file->f_inode->i_mode))
{
vfs_close(p_file);
valid = 0;
}
if (pcdfsi->cdi_flags & CDI_ISVALID)
{
vfs_close(pcdfsd->u.p_file);
}
if (valid)
{
pcdfsd->u.is_valid = 1;
pcdfsd->u.p_file = p_file;
return NO_ERROR;
}
else
{
vfs_close(p_file);
return ERROR_PATH_NOT_FOUND;
}
}
break;
case CD_FREE:
pcdfsd = VDHQueryLin(parms->pcdfsd);
if (trace_FS_CHDIR)
{
kernel_printf("FS_CHDIR( CD_FREE )");
}
if (pcdfsd->u.is_valid == 1)
{
pcdfsd->u.is_valid = 0;
if ((rc = vfs_close(pcdfsd->u.p_file)) != NO_ERROR)
{
fs_err(FUNC_FS_CHDIR, FUNC_CLOSE, rc, THISFILE, __LINE__);
}
// return rc;
}
else
{
rc = NO_ERROR;
}
break;
default:
fs_log("FS_CHDIR : invalid flag");
rc = ERROR_INVALID_PARAMETER;
}
return rc;
}
int main(void) {
char *status;
if((status = malloc(STATUS_LENGTH*sizeof(char))) == NULL){
printf("Cannot allocate memory for status");
return 0;
}
char *datetime = NULL;
char state_bat[12];
int bat1, energy_full; // bat2;
int rem_hours = 0, rem_min = 0, rem_sec = 0;
long rem_usec = 0;
char *net_intf, *ip = NULL;
if((net_intf = malloc(5*sizeof(char))) == NULL){
printf("Cannot allocate memory for net_intf");
return 0;
}
if((ip = malloc(100*sizeof(char))) == NULL){
printf("Cannot allocate memory for ip");
return 0;
}
char net_displ[50];
long left_volume;
long right_volume;
int mem_used;
int mem_available;
float cpu_avg_freq;
long usec1, usec2 = 0;
struct timeval time1, time2;
int connected = 0;
int energy1, energy2, dummy = 0;
int count = 0;
char *mpc_vol, *mpc_state, *mpc_song = NULL;
if((mpc_vol = malloc(3*sizeof(char))) == NULL){
printf("Cannot allocate memory for mpc_vol");
return 0;
}
if((mpc_state = malloc(5*sizeof(char))) == NULL){
printf("Cannot allocate memory for mpc_state");
return 0;
}
if((mpc_song = malloc(100*sizeof(char))) == NULL){
printf("Cannot allocate memory for mpc_song");
return 0;
}
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(stderr, "Cannot open display.\n");
return 0;
}
strcpy(state_bat, "unknown");
for (;;sleep(1)) {
bat1 = getbattery(&dummy, &energy_full);
connected = net(&net_intf, &ip);
datetime = getdatetime();
getvolume(&left_volume, &right_volume);
getmemoryusage(&mem_available, &mem_used);
getcpuusage(&cpu_avg_freq);
if (connected == 1) sprintf(net_displ, "%s: %s", net_intf, ip);
else sprintf(net_displ, "not connected");
//mpc_stat(&mpc_vol, &mpc_state, &mpc_song);
if (count == 0) {
usec1 = time_usec(&time1);
getbattery(&energy1, &energy_full);
count++;
} else if (count >= 5) {
count = 0;
usec2 = time_usec(&time2);
getbattery(&energy2, &energy_full);
if ((energy2 - energy1) < 0){
rem_usec = ((float)(usec2-usec1))*(((float)(energy1+energy2))/((float)(2*(energy1-energy2))));
strcpy(state_bat, "discharging");
} else if ((energy2 - energy1) > 0) {
rem_usec = (((float)(usec2-usec1))*((float)energy_full)/((float)(energy2-energy1)))*(1-(((float)(energy2+energy1))/((float)(2*energy_full))));
strcpy(state_bat, "charging");
} else if ( (energy2 == energy1) && bat1 >= 100) {
rem_usec = 0;
strcpy(state_bat, "charged");
} else {
rem_usec = 0;
strcpy(state_bat, "unknown");
}
rem_hours = (int)(rem_usec/(1e6*60*60));
rem_min = (int)((rem_usec/(1e6*60)) - rem_hours*60);
rem_sec = (int)((rem_usec/(1e6)) - rem_hours*60*60 - rem_min*60);
if ((bat1 < 15) && (strcmp(state_bat, "discharging") == 0)) {
system("mplayer /home/andrea/.local/statusbar/sound/siren.mp3");
}
} else {
count++;
}
// snprintf(status, STATUS_LENGTH, "MPC: status: %s - song: %s | %s | volume left %i - right %i | Battery %d%% (%s %d h %d min %d s) | %s", mpc_state, mpc_song, net_displ, (int)left_volume, (int)right_volume, bat1, state_bat, rem_hours, rem_min, rem_sec, datetime);
snprintf(status, STATUS_LENGTH, "CPU (avg) %4.3f MHz | RAM used %d%% available %d%% | %s | volume left %i - right %i | Battery %d%% (%s %d h %d min %d s) | %s", cpu_avg_freq, mem_used, mem_available, net_displ, (int)left_volume, (int)right_volume, bat1, state_bat, rem_hours, rem_min, rem_sec, datetime);
setstatus(status);
}
free(mpc_song);
free(mpc_state);
free(mpc_vol);
free(net_intf);
free(ip);
free(datetime);
free(status);
XCloseDisplay(dpy);
return 0;
}
/*
* struct fs32_opencreate_parms {
* PTR16 pfgenflag;
* PTR16 pEABuf;
* unsigned short attr;
* PTR16 pAction;
* unsigned short openflag;
* unsigned long openmode;
* PTR16 psffsd;
* PTR16 psffsi;
* unsigned short iCurDirEnd;
* PTR16 pName;
* PTR16 pcdfsd;
* PTR16 pcdfsi;
* };
*/
int FS32ENTRY fs32_opencreate(struct fs32_opencreate_parms *parms)
{
char *pName;
struct cdfsi32 *pcdfsi;
union cdfsd32 *pcdfsd;
struct sffsi32 *psffsi;
union sffsd32 *psffsd;
unsigned short *pAction;
int rc;
struct super_block *sb;
struct file *p_file, *dir;
UINT32 openmode, DOSmode;
UINT32 accessmode;
UINT16 newflag, existflag;
char component[CCHMAXPATH];
char parent[CCHMAXPATH];
struct inode *inode;
struct inode *inode_parent;
struct inode *base;
char *tmp;
ino_t ino_no;
psffsi = VDHQueryLin(parms->psffsi);
psffsd = VDHQueryLin(parms->psffsd);
if (parms->pcdfsi.seg)
pcdfsi = VDHQueryLin(parms->pcdfsi);
else
pcdfsi = 0;
if (parms->pcdfsd.seg)
pcdfsd = VDHQueryLin(parms->pcdfsd);
else
pcdfsd = 0;
pName = VDHQueryLin(parms->pName);
pAction = VDHQueryLin(parms->pAction);
if (trace_FS_OPENCREATE)
{
kernel_printf("FS_OPENCREATE(%s)", pName);
}
#ifdef FS_TRACE
if (parms->ulOpenMode & OPEN_FLAGS_DASD)
{
fs_log("OPEN_FLAGS_DASD");
}
if (parms->ulOpenMode & OPEN_FLAGS_WRITE_THROUGH)
{
fs_log("OPEN_FLAGS_WRITE_THROUGH");
}
if (parms->ulOpenMode & OPEN_FLAGS_FAIL_ON_ERROR)
{
fs_log("OPEN_FLAGS_FAIL_ON_ERROR");
}
if (parms->ulOpenMode & OPEN_FLAGS_NO_CACHE)
{
fs_log("OPEN_FLAGS_NO_CACHE");
}
if (parms->ulOpenMode & OPEN_FLAGS_NOINHERIT)
{
fs_log("OPEN_FLAGS_NO_INHERIT");
}
#endif
accessmode = parms->ulOpenMode & OPEN_ACCESS_MASK;
if (accessmode == OPEN_ACCESS_READONLY)
{
#ifdef FS_TRACE
fs_log("OPEN_ACCESS_READONLY");
#endif
openmode = OPENMODE_READONLY;
}
if (accessmode == OPEN_ACCESS_WRITEONLY)
{
#ifdef FS_TRACE
fs_log("OPEN_ACCESS_WRITEONLY");
#endif
openmode = OPENMODE_WRITEONLY;
}
if (accessmode == OPEN_ACCESS_READWRITE)
{
#ifdef FS_TRACE
fs_log("OPEN_ACCESS_READWRITE");
#endif
openmode = OPENMODE_READWRITE;
}
#ifdef FS_TRACE
if (accessmode == OPEN_ACCESS_EXECUTE)
{
fs_log("OPEN_ACCESS_EXECUTE");
}
#endif
newflag = parms->openflag & OPEN_ACTION_NEW_MASK;
#ifdef FS_TRACE
if (newflag == OPEN_ACTION_FAIL_IF_NEW)
{
fs_log("OPEN_ACTION_FAIL_IF_NEW");
}
if (newflag == OPEN_ACTION_CREATE_IF_NEW)
{
fs_log("OPEN_ACTION_CREATE_IF_NEW");
}
#endif
existflag = parms->openflag & OPEN_ACTION_EXIST_MASK;
#ifdef FS_TRACE
if (existflag == OPEN_ACTION_OPEN_IF_EXISTS)
{
fs_log("OPEN_ACTION_OPEN_IF_EXISTS");
}
if (existflag == OPEN_ACTION_FAIL_IF_EXISTS)
{
fs_log("OPEN_ACTION_FAIL_IF_EXISTS");
}
if (existflag == OPEN_ACTION_REPLACE_IF_EXISTS)
{
fs_log("OPEN_ACTION_REPLACE_IF_EXISTS");
}
#endif
if ((!Read_Write) &&
((accessmode == OPEN_ACCESS_READWRITE) ||
(accessmode == OPEN_ACCESS_WRITEONLY)))
{
fs_log("FS_OPENCREATE() - Write access not enabled");
return ERROR_WRITE_PROTECT;
}
//
// Direct access open of the whole device
//
if (parms->ulOpenMode & OPEN_FLAGS_DASD)
{
sb = getvolume(psffsi->sfi_hVPB);
kernel_printf("OPEN_FLAGS_DASD");
if ((p_file = _open_by_inode(sb, INODE_DASD, openmode)) == 0)
{
kernel_printf("FS_OPENCREATE() - couldn't DASD open %s", pName);
return ERROR_OPEN_FAILED;
}
psffsd->f = p_file;
psffsi->sfi_tstamp = ST_SCREAT | ST_PCREAT;
psffsi->sfi_size = p_file->f_inode->i_size;
psffsi->sfi_position = p_file->f_pos;
date_unix2dos(p_file->f_inode->i_ctime, &(psffsi->sfi_ctime), &(psffsi->sfi_cdate));
date_unix2dos(p_file->f_inode->i_atime, &(psffsi->sfi_atime), &(psffsi->sfi_adate));
date_unix2dos(p_file->f_inode->i_mtime, &(psffsi->sfi_mtime), &(psffsi->sfi_mdate));
return NO_ERROR;
}
//
// Now that we treated the OPEN_FLAGS_DASD special case, lets treat the general case :
// Try to open the file readonly
// Success : the file exists
// if !S_ISDIR && !S_ISREG => error
// if OPEN_ACTION_FAIL_IF_EXISTS set => error
// if OPEN_ACTION_OPEN_IF_EXISTS set
// <test file attrs>
// change the open mode and return OK
// if OPEN_ACTION_REPLACE_IF_EXISTS set
// OPEN_ACCESS_READONLY or OPEN_ACCESS_EXECUTE set => error
// OPEN_ACCESS_READWRITE or OPEN_ACCESS_WRITEONLY set
// truncate
// change openmode and return
// Failure : the file does not exist
// OPEN_ACCESS_READONLY or OPEN_ACCESS_EXECUTE set => error
// OPEN_ACCESS_READWRITE or OPEN_ACCESS_WRITEONLY set
// if OPEN_ACTION_CREATE_IF_NEW set
// try to create the file
// open the file and return
// if OPEN_ACTION_FAIL_IF_NEW set => error
rc = ERROR_INVALID_PARAMETER;
if (parms->iCurDirEnd != CURDIREND_INVALID)
{
tmp = pName + parms->iCurDirEnd;
if ((pcdfsd->u.p_file) && (pcdfsd->u.p_file->f_magic == FILE_MAGIC))
{
base = pcdfsd->u.p_file->f_inode;
if (base)
{
sb = base->i_sb;
rc = NO_ERROR;
}
}
}
else
{
sb = getvolume(psffsi->sfi_hVPB);
if ((sb) && (sb->s_magic_internal == SUPER_MAGIC))
{
tmp = skip_drive(pName);
base = sb->s_mounted;
if (base)
{
rc = NO_ERROR;
}
}
}
if (rc != NO_ERROR)
{
return rc;
}
p_file = open_by_name(base, tmp, openmode);
if (p_file)
{ // The file exists
//
// If it's not a regular file or a directory we cannot open
//
if (!S_ISREG(p_file->f_inode->i_mode))
{
// kernel_printf("Can't FS_OPENCREATE - %s is not a regular file", pName);
if ((rc = vfs_close(p_file)) != NO_ERROR)
{
fs_err(FUNC_FS_OPENCREATE, FUNC_CLOSE, rc, FILE_TEST_C, __LINE__);
return rc;
}
return ERROR_ACCESS_DENIED;
}
//
// if OPEN_ACTION_FAIL_IF_EXISTS set => error
//
if (existflag == OPEN_ACTION_FAIL_IF_EXISTS)
{
#ifdef FS_TRACE
fs_log("Can't FS_OPENCREATE() - File exists & OPEN_ACTION_FAIL_IF_EXISTS");
#endif
if ((rc = vfs_close(p_file)) != NO_ERROR)
{
fs_err(FUNC_FS_OPENCREATE, FUNC_CLOSE, rc, FILE_TEST_C, __LINE__);
return rc;
}
return ERROR_FILE_EXISTS;
}
//
// if OPEN_ACTION_OPEN_IF_EXISTS : OK
//
if (existflag == OPEN_ACTION_OPEN_IF_EXISTS)
{
*pAction = FILE_EXISTED;
}
//
// if OPEN_ACTION_REPLACE_IF_EXISTS : truncate
//
if (existflag == OPEN_ACTION_REPLACE_IF_EXISTS)
{
p_file->f_inode->i_size = psffsi->sfi_size;
p_file->f_inode->i_op->truncate(p_file->f_inode);
p_file->f_inode->i_dirt = 1;
p_file->f_flags = O_TRUNC;
*pAction = FILE_TRUNCATED;
#if 0
psffsi->sfi_tstamp = ST_PWRITE | ST_SWRITE;
#else
/*
* Time stamping is done by inode routines - Only propagate value.
*/
psffsi->sfi_tstamp = ST_PWRITE;
#endif
}
}
else
{ // The file doesn't exist
ExtractPath(pName, __StackToFlat(parent));
ExtractName(pName, __StackToFlat(component));
//
// We try to open the parent dir
//
if ((dir = open_by_name(sb->s_mounted, Skip_drive(__StackToFlat(parent)), OPENMODE_READONLY)) == 0)
{
// kernel_printf("FS_OPENCREATE() - The parent directory %s doesn't seem to exist", parent);
return ERROR_PATH_NOT_FOUND;
}
//
// The parent dir exists
//
//
// If the file is open for execution : error (it doesn't even exist)
//
if (accessmode == OPEN_ACCESS_EXECUTE)
{
#ifdef FS_TRACE
fs_log("Can't FS_OPENCREATE() - File doesn't exist & OPEN_ACCESS_EXECUTE");
#endif
if ((rc = vfs_close(dir)) != NO_ERROR)
{
fs_err(FUNC_FS_OPENCREATE, FUNC_CLOSE, rc, FILE_TEST_C, __LINE__);
return rc;
}
return ERROR_FILE_NOT_FOUND;
}
//
// If the file is open for writing or readwrite ...
//
if ((accessmode == OPEN_ACCESS_READONLY) ||
(accessmode == OPEN_ACCESS_READWRITE) ||
(accessmode == OPEN_ACCESS_WRITEONLY))
{
if (newflag == OPEN_ACTION_FAIL_IF_NEW)
{
#ifdef FS_TRACE
fs_log("Can't FS_OPENCREATE() - File doesn't exist & OPEN_ACTION_FAIL_IF_NEW");
#endif
if ((rc = vfs_close(dir)) != NO_ERROR)
{
fs_err(FUNC_FS_OPENCREATE, FUNC_CLOSE, rc, FILE_TEST_C, __LINE__);
return rc;
}
return ERROR_OPEN_FAILED;
}
if (newflag == OPEN_ACTION_CREATE_IF_NEW)
{
// ino_no = dir->f_inode->i_ino;
inode_parent = dir->f_inode;
inode_parent->i_count++;
if ((rc = vfs_close(dir)) != NO_ERROR)
{
fs_err(FUNC_FS_OPENCREATE, FUNC_CLOSE, rc, THISFILE, __LINE__);
return rc;
}
// inode_parent = iget(sb, ino_no);
inode_parent->i_count++;
down(&inode_parent->i_sem);
rc = inode_parent->i_op->create(inode_parent, __StackToFlat(component), strlen(component), S_IRWXU | S_IFREG, __StackToFlat(&inode));
up(&inode_parent->i_sem);
if (rc)
{
kernel_printf("Couldn't create %s", pName);
iput(inode_parent);
return rc;
}
ino_no = inode->i_ino;
iput(inode_parent);
iput(inode);
if ((p_file = _open_by_inode(sb, ino_no, openmode)) == 0)
{
kernel_printf("open_by_inode(%lu) failed in FS_OPENCREATE", ino_no);
return ERROR_OPEN_FAILED;
}
p_file->f_inode->i_size = psffsi->sfi_size;
p_file->f_inode->i_dirt = 1;
p_file->f_flags = O_CREAT;
*pAction = FILE_CREATED;
#if 0
psffsi->sfi_tstamp = ST_SCREAT | ST_PCREAT | ST_PWRITE | ST_SWRITE;
#else
/*
* Time stamping is done by inode routines - Only propagate value.
*/
psffsi->sfi_tstamp = ST_PCREAT | ST_PWRITE;
#endif
}
}
}
psffsd->f = p_file;
/*
* Time stamping is done by inode routines - Only propagate value.
*/
#if 0
psffsi->sfi_tstamp |= ST_PREAD | ST_SREAD;
#else
/*
* Time stamping is done by inode routines - Only propagate value.
*/
psffsi->sfi_tstamp |= ST_PREAD;
#endif
psffsi->sfi_size = p_file->f_inode->i_size;
psffsi->sfi_position = p_file->f_pos;
// kernel_printf("date = %u/%u/%u", (pCommon->dateCreate) & 31, (pCommon->dateCreate >> 5) & 15 , (pCommon->dateCreate) >> 9);
date_unix2dos(p_file->f_inode->i_ctime, &(psffsi->sfi_ctime), &(psffsi->sfi_cdate));
date_unix2dos(p_file->f_inode->i_atime, &(psffsi->sfi_atime), &(psffsi->sfi_adate));
date_unix2dos(p_file->f_inode->i_mtime, &(psffsi->sfi_mtime), &(psffsi->sfi_mdate));
psffsi->sfi_DOSattr = (unsigned char)Linux_To_DOS_Attrs(p_file->f_inode, __StackToFlat(component));
if (write_through_support)
{
if ((parms->ulOpenMode & OPEN_FLAGS_WRITE_THROUGH) ||
(parms->ulOpenMode & OPEN_FLAGS_NO_CACHE))
{
p_file->f_flags |= O_SYNC;
p_file->f_inode->i_flags |= MS_SYNCHRONOUS;
}
}
return NO_ERROR;
}
