static void pprint_get_mountlist(gboolean allfs)
{
glibtop_mountlist buf;
glibtop_mountentry *entries;
size_t i;
entries = glibtop_get_mountlist(&buf, allfs);
HEADER_PPRINT(glibtop_get_mountlist);
printf("glibtop_get_mountlist (allfs = %d)\n", allfs);
PPRINT(flags, "%#llx");
PPRINT(number, "%llu");
PPRINT(total, "%llu");
PPRINT(size, "%llu");
printf("\t%4llu B entries[%llu] = \n\t\t{\n", buf.total, buf.number);
for(i = 0; i < buf.number; ++i)
{
printf("\t\t .%lu = { .dev = %#llx,"
" .devname = \"%s\","
" .mountir = \"%s\","
" .type = \"%s\" }\n",
(unsigned long) i, entries[i].dev,
entries[i].devname,
entries[i].mountdir,
entries[i].type);
}
printf("\t\t}\n");
FOOTER_PPRINT();
g_free(entries);
}
int
arp_request(u32bits dst)
{
unsigned waiting;
#ifdef ARPDEBUG
PPRINT(("Start arp_request(0x%x)\n", dst));
#endif
arp_waiting = dst;
(void)arp_output();
settimeout(ARP_RETRANSMIT);
waiting = ARP_RETRANSMIT;
while (arp_waiting != 0 && waiting <= 60000) {
if (isatimeout()) {
#ifdef ARPDEBUG
PPRINT(("ARP request sent\n"));
#endif
arp_output();
settimeout(ARP_RETRANSMIT);
waiting += ARP_RETRANSMIT;
}
if (is_intr_char())
return (NETBOOT_ABORT);
(*dlink.dl_input)(arp_buffer, sizeof(arp_buffer));
}
return (arp_waiting == 0 ? NETBOOT_SUCCESS : NETBOOT_ERROR);
}
int main(void)
{
DPRINT("Initing startlevel 1");
if(0!=init_startlevel1())
{
PPRINT("Failed to init startlevel 1");
}
DPRINT("Initing startlevel 2");
if(0!=init_startlevel2())
{
PPRINT("Failed to init startlevel 2");
}
DPRINT("Initing startlevel 3");
if(0!=init_startlevel3())
{
PPRINT("Failed to init startlevel 3");
}
DPRINT("Initing startlevel 4");
if(0!=init_startlevel4())
{
PPRINT("Failed to init startlevel 4");
}
DPRINT("Initing startlevel 5");
if(0!=init_startlevel5())
{
PPRINT("Failed to init startlevel 5");
}
DPRINT("Oh Joy, I would be Up now!");
getoonbaby(configGetServeramnt());
deinit_startlevel5();
return 0;
}
static void pprint_get_uptime(void)
{
glibtop_uptime buf;
glibtop_get_uptime(&buf);
HEADER_PPRINT(glibtop_get_uptime);
PPRINT(flags, "%#llx");
PPRINT(uptime, "%f");
PPRINT(idletime, "%f");
PPRINT(boot_time, "%llu");
FOOTER_PPRINT();
}
static void pprint_get_loadavg(void)
{
glibtop_loadavg buf;
glibtop_get_loadavg(&buf);
HEADER_PPRINT(glibtop_get_loadavg);
PPRINT(flags, "%#llx");
PPRINT_ARRAY(loadavg, 3, "%f");
PPRINT(nr_running, "%llu");
PPRINT(nr_tasks, "%llu");
PPRINT(last_pid, "%llu");
FOOTER_PPRINT();
}
static void pprint_get_netload(const char *iface)
{
glibtop_netload buf;
glibtop_get_netload(&buf, iface);
HEADER_PPRINT(glibtop_get_netload);
printf("glibtop_get_netload (iface = \"%s\")\n", iface);
PPRINT(flags, "%#llx");
FOOTER_PPRINT();
}
static void pprint_get_proc_affinity(pid_t pid)
{
glibtop_proc_affinity buf;
guint32 i;
guint16* cpus;
cpus = glibtop_get_proc_affinity(&buf, pid);
HEADER_PPRINT(glibtop_get_proc_affinity);
PPRINT(flags, "%#llx");
PPRINT(number, "%u");
PPRINT(all, "%d");
printf("\taffinity=");
for (i = 0; i < buf.number; i++) {
printf("%d, ", cpus[i]);
}
putchar('\n');
FOOTER_PPRINT();
}
static void pprint_get_mem(void)
{
glibtop_mem buf;
glibtop_get_mem(&buf);
HEADER_PPRINT(glibtop_get_mem);
PPRINT(flags, "%#llx");
PPRINT(total, "%llu");
PPRINT(used, "%llu");
PPRINT(free, "%llu");
PPRINT(shared, "%llu");
PPRINT(buffer, "%llu");
PPRINT(cached, "%llu");
PPRINT(user, "%llu");
PPRINT(locked, "%llu");
FOOTER_PPRINT();
}
Sstartuplock *initstuplock()
{
Sstartuplock *_this=malloc(sizeof(Sstartuplock));
if(NULL==_this)
{
PPRINT("Malloc Failed at *initstuplock()");
return NULL;
}
_this->lockval=MbotAtomic32Init();
if(NULL==_this->lockval)
{
PPRINT("Malloc Failed at *initstuplock()");
free(_this);
return NULL;
}
_this->init=&initstuplock;
_this->uninit=&uninitstuplock;
_this->lock=&lockstuplock;
_this->release=&releasestuplock;
_this->islocked=&islockedstuplock;
return _this;
}
static void pprint_get_fsusage(const char *mountpoint)
{
glibtop_fsusage buf;
glibtop_get_fsusage(&buf, mountpoint);
HEADER_PPRINT(glibtop_get_fsusage);
printf("pprint_get_fsusage (mountpoint = \"%s\"\n", mountpoint);
PPRINT(flags, "%#llx");
PPRINT(blocks, "%llu");
PPRINT(bfree, "%llu");
PPRINT(bavail, "%llu");
PPRINT(files, "%llu");
PPRINT(ffree, "%llu");
PPRINT(block_size, "%u");
PPRINT(read, "%llu");
PPRINT(write, "%llu");
FOOTER_PPRINT();
}
int callbacklist_init(SServerCallbackList **lpp,ServerCallbackF cb,void *userptr)
{
SServerCallbackList *lp;
lp=calloc(1,sizeof(SServerCallbackList));
*lpp=lp;
if(NULL==lp)
{
PPRINT("Malloc failed when Initing callbacklist! Out of mem??");
return -1;
}
lp->args.userdataptr=userptr;
lp->callback=cb;
lp->next=NULL;
return 0;
}
static void pprint_get_msg_limits(void)
{
glibtop_msg_limits buf;
glibtop_get_msg_limits(&buf);
HEADER_PPRINT(glibtop_get_msg_limits);
PPRINT(flags, "%#llx");
PPRINT(msgpool, "%llu");
PPRINT(msgmap, "%llu");
PPRINT(msgmax, "%llu");
PPRINT(msgmnb, "%llu");
PPRINT(msgmni, "%llu");
PPRINT(msgssz, "%llu");
PPRINT(msgtql, "%llu");
FOOTER_PPRINT();
}
int callbacklist_add(SServerCallbackList *list,ServerCallbackF cb,void *userptr)
{
while(NULL!=list->next)
{
list=list->next;
}
list->next=calloc(1,sizeof(SServerCallbackList));
if(NULL==list->next)
{
PPRINT("Malloc failed when adding callback to list! Out of mem??");
return -1;
}
list->next->callback=cb;
list->next->args.userdataptr=userptr;
list->next=NULL;
return 0;
}
static void pprint_get_proc_mem(pid_t pid)
{
glibtop_proc_mem buf;
glibtop_get_proc_mem(&buf, pid);
HEADER_PPRINT(glibtop_get_proc_mem);
PPRINT(flags, "%#llx");
PPRINT(size, "%llu");
PPRINT(vsize, "%llu");
PPRINT(resident, "%llu");
PPRINT(share, "%llu");
PPRINT(rss, "%llu");
PPRINT(rss_rlim, "%llu");
FOOTER_PPRINT();
}
static void pprint_get_proc_kernel(pid_t pid)
{
glibtop_proc_kernel buf;
glibtop_get_proc_kernel(&buf, pid);
HEADER_PPRINT(glibtop_get_proc_kernel);
PPRINT(flags, "%#llx");
PPRINT(k_flags, "%llu");
PPRINT(min_flt, "%llu");
PPRINT(maj_flt, "%llu");
PPRINT(cmin_flt, "%llu");
PPRINT(cmaj_flt, "%llu");
FOOTER_PPRINT();
}
static void pprint_get_swap(void)
{
glibtop_swap buf;
glibtop_get_swap(&buf);
HEADER_PPRINT(glibtop_get_swap);
PPRINT(flags, "%#llx");
PPRINT(total, "%llu");
PPRINT(used, "%llu");
PPRINT(free, "%llu");
PPRINT(pagein, "%llu");
PPRINT(pageout, "%llu");
FOOTER_PPRINT();
}
static void
arp_output()
{
struct frame_arp *ap;
u8bits *p;
unsigned i;
#ifdef ARPDEBUG
PPRINT(("Start arp_output()\n"));
#endif
ap = (struct frame_arp *)&arp_buffer[dlink.dl_hlen];
ap->arp_hrd = htons(dlink.dl_type);
ap->arp_pro = htons(ETHERNET_TYPE_IP);
ap->arp_hln = dlink.dl_len;
ap->arp_pln = sizeof (u32bits);
ap->arp_op = htons(ARPOP_REQUEST);
p = (u8bits *)(ap + 1);
for (i = 0; i < dlink.dl_len; i++)
*p++ = dlink.dl_laddr[i];
*p++ = (udpip_laddr >> 24) & 0xFF;
*p++ = (udpip_laddr >> 16) & 0xFF;
*p++ = (udpip_laddr >> 8) & 0xFF;
*p++ = udpip_laddr & 0xFF;
for (i = 0; i < dlink.dl_len; i++)
*p++ = '\0';
*p++ = (arp_waiting >> 24) & 0xFF;
*p++ = (arp_waiting >> 16) & 0xFF;
*p++ = (arp_waiting >> 8) & 0xFF;
*p++ = arp_waiting & 0xFF;
switch (dlink.dl_type) {
case ARPHRD_ETHERNET:
ether_output(arp_buffer, ARP_BUFLEN(ap->arp_hln), ether_broadcast, ETHERNET_TYPE_ARP);
break;
default:
printf("Unknown dlink type 0x%x\n", dlink.dl_type);
break;
}
}
void
arp_input(void *addr,
unsigned len)
{
struct frame_arp *ap;
struct frame_arp *ap1;
unsigned i;
u8bits *p;
u32bits ip;
#ifdef ARPDEBUG
PPRINT(("Start arp_input(0x%x, 0x%x)\n", addr, len));
#endif
ap = (struct frame_arp *)addr;
if (ntohs(ap->arp_hrd) != dlink.dl_type ||
ntohs(ap->arp_pro) != ETHERNET_TYPE_IP ||
ap->arp_hln != dlink.dl_len ||
ap->arp_pln != sizeof (u32bits) ||
len < sizeof (struct frame_arp) + 2 * (ap->arp_hln + sizeof (u32bits))) {
#ifdef ARPDEBUG
PPRINT(("arp_input: Bad type\n"));
#endif
return;
}
ap->arp_op = ntohs(ap->arp_op);
switch (ap->arp_op) {
case ARPOP_REQUEST:
p = (u8bits *)(ap + 1) + 2 * ap->arp_hln + ap->arp_pln;
ip = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
if (udpip_laddr != ip) {
#ifdef ARPDEBUG
PPRINT(("arp_input: Not for us\n"));
#endif
return;
}
ap1 = (struct frame_arp *)&arp_buffer[dlink.dl_hlen];
ap1->arp_hrd = htons(dlink.dl_type);
ap1->arp_pro = htons(ETHERNET_TYPE_IP);
ap1->arp_hln = dlink.dl_len;
ap1->arp_pln = sizeof (u32bits);
ap1->arp_op = htons(ARPOP_REPLY);
p = (u8bits *)(ap1 + 1);
for (i = 0; i < dlink.dl_len; i++)
*p++ = dlink.dl_laddr[i];
*p++ = (udpip_laddr >> 24) & 0xFF;
*p++ = (udpip_laddr >> 16) & 0xFF;
*p++ = (udpip_laddr >> 8) & 0xFF;
*p++ = udpip_laddr & 0xFF;
for (i = 0; i < dlink.dl_len + sizeof (u32bits); i++)
*p++ = ((u8bits *)(ap + 1))[i];
len = sizeof (struct frame_arp) + 2 * (dlink.dl_len + 4);
switch (dlink.dl_type) {
case ARPHRD_ETHERNET:
(void)ether_output(arp_buffer, ARP_BUFLEN(ap1->arp_hln),
(u8bits *)(ap + 1), ETHERNET_TYPE_ARP);
break;
default:
printf("Unknown dlink type 0x%x\n", dlink.dl_type);
break;
}
return;
case ARPOP_REPLY:
if (arp_waiting != 0) {
p = (u8bits *)(ap + 1) + ap->arp_hln;
ip = 0;
for (i = 0; i < sizeof (u32bits); i++)
ip = (ip << 8) | *p++;
if (arp_waiting == ip) {
arp_waiting = 0;
p = (u8bits *)(ap + 1);
for (i = 0; i < ap->arp_hln; i++) {
dlink.dl_raddr[i] = *p++;
}
break;
}
}
#ifdef ARPDEBUG
PPRINT(("arp_input: Bad sender (%x)\n", ap + 1));
#endif
break;
default:
#ifdef ARPDEBUG
PPRINT(("arp_input: Bad operation (%x)\n", ap->arp_op));
#endif
break;
}
}
void doHough(std::vector<payload> readings, int lineThresh, int pointThresh)
{
std::vector<float> maxVal(2), res(2);
std::vector<float> minVal(2);
std::vector<float> vote(2);
std::vector<float> voteLoc(2);
/**
* LINE SPACE
* RHO: The perpendicular distance of the line from origin
* THETA: Angle the perpendicular from the origin to the line
* makes with +X axis
*
* beta: Angular error of ultrasonic sensor, -15deg < beta < 15deg
*/
maxVal[RHO] = 15000.0F; // in millimetres
maxVal[THETA] = (float) 2 * M_PI; // in radians
res[RHO] = 100;
res[THETA] = M_PI / 180 * 5;
houghSpace linespace (res, maxVal);
for (auto &p: readings) {
for (float beta = -M_PI/12; beta <= M_PI/12; beta += M_PI/180) {
// Refer to the paper for the derivation
vote[THETA] = p.loc.theta + beta;
vote[THETA] = fmod(vote[THETA], 2 * M_PI);
if (vote[THETA] < 0) {
vote[THETA] += 2 * M_PI;
}
vote[RHO] = std::abs(p.reading + (p.loc.x * cosf(vote[THETA]))
+ (p.loc.y * sinf(vote[THETA])));
voteLoc[X] = p.loc.x + p.reading * cosf(vote[THETA]);
voteLoc[Y] = p.loc.y + p.reading * sinf(vote[THETA]);
assert(vote[RHO] <= maxVal[RHO]);
assert(vote[THETA] <= maxVal[THETA]);
PPRINT(vote[RHO]);
PPRINT(vote[THETA]);
PPRINT(voteLoc[X]);
PPRINT(voteLoc[Y]);
linespace.addVote(vote, voteLoc);
}
}
auto lineF (linespace.getMaxima(lineThresh));
std::ofstream lout ("lines.txt");
for (auto &p: lineF) {
for (auto &q: p.first) {
lout << q << " ";
}
lout << std::endl;
}
std::ofstream lsout("line_segments.txt");
auto lineSegments = getLineSegments(lineF);
for (auto &ls : lineSegments) {
lsout << ls.first.first << ' ' //X1
<< ls.first.second << ' ' //Y1
<< ls.second.first << ' ' //X2
<< ls.second.second << ' ' //Y2
<< std::endl;
}
}
void doHough(std::vector<payload> readings, int lineThresh, int pointThresh)
{
std::vector<float> maxVal(2), res(2);
std::vector<float> minVal(2);
std::vector<float> vote(2);
/**
* LINE SPACE
* RHO: The perpendicular distance of the line from origin
* THETA: Angle the perpendicular from the origin to the line
* makes with +X axis
*
* beta: Angular error of ultrasonic sensor, -15deg < beta < 15deg
*/
maxVal[RHO] = 15000.0F; // in millimetres
maxVal[THETA] = (float) 2 * M_PI; // in radians
res[RHO] = 100;
res[THETA] = M_PI / 180 * 5;
houghSpace linespace (res, maxVal);
for (auto &p: readings) {
for (float beta = -M_PI/12; beta <= M_PI/12; beta += M_PI/180) {
// Refer to the paper for the derivation
vote[THETA] = p.loc.theta + beta;
vote[THETA] = fmod(vote[THETA], 2 * M_PI);
if (vote[THETA] < 0) {
vote[THETA] += 2 * M_PI;
}
vote[RHO] = std::abs(p.reading + (p.loc.x * cosf(vote[THETA]))
+ (p.loc.y * sinf(vote[THETA])));
assert(vote[RHO] <= maxVal[RHO]);
assert(vote[THETA] <= maxVal[THETA]);
PPRINT(vote[RHO]);
PPRINT(vote[THETA]);
linespace.addVote(vote);
}
}
std::vector< std::vector<float> > lineF (linespace.getMaxima(lineThresh));
std::ofstream lout ("lines.txt");
for (auto &p: lineF) {
for (auto &q: p) {
lout << q << " ";
}
lout << std::endl;
}
//std::cout << linespace;
/**
* POINT SPACE
* X: X-coordinate of point
* Y: Y-coordinate of point
*
* beta: Angular error of ultrasonic sensor, -15deg < beta < 15deg
*/
maxVal[X] = 15000.0F; // in millimetres
maxVal[Y] = 15000.0F; // in millimetres
minVal[X] = -15000.0F;
minVal[Y] = -15000.0F;
res[X] = 10;
res[Y] = 10;
houghSpace pointspace (res, maxVal, minVal);
for (auto &p: readings) {
for (float beta = -M_PI/12; beta <= M_PI/12; beta += M_PI/180) {
vote[X] = p.loc.x + (p.reading * cosf(p.loc.theta + beta));
vote[Y] = p.loc.y + (p.reading * sinf(p.loc.theta + beta));
assert(vote[X] <= maxVal[X]);
assert(vote[Y] <= maxVal[Y]);
PPRINT(vote[X]);
PPRINT(vote[Y]);
pointspace.addVote(vote);
}
}
std::vector< std::vector<float> > pointF (pointspace.getMaxima(pointThresh));
std::ofstream pout ("points.txt");
for (auto &p: pointF) {
for (auto &q: p) {
pout << q << " ";
}
pout << std::endl;
}
//std::cout << pointspace;
}
static void pprint_get_cpu(void)
{
glibtop_cpu buf;
glibtop_get_cpu(&buf);
HEADER_PPRINT(glibtop_get_cpu);
PPRINT(flags, "%#llx");
PPRINT(total, "%llu");
PPRINT(user, "%llu");
PPRINT(nice, "%llu");
PPRINT(sys, "%llu");
PPRINT(idle, "%llu");
PPRINT(iowait, "%llu");
PPRINT(irq, "%llu");
PPRINT(softirq, "%llu");
PPRINT(frequency, "%llu");
PPRINT_ARRAY(xcpu_total, GLIBTOP_NCPU, "%llu");
PPRINT_ARRAY(xcpu_user, GLIBTOP_NCPU, "%llu");
PPRINT_ARRAY(xcpu_nice, GLIBTOP_NCPU, "%llu");
PPRINT_ARRAY(xcpu_sys, GLIBTOP_NCPU, "%llu");
PPRINT_ARRAY(xcpu_idle, GLIBTOP_NCPU, "%llu");
PPRINT_ARRAY(xcpu_iowait, GLIBTOP_NCPU, "%llu");
PPRINT_ARRAY(xcpu_irq, GLIBTOP_NCPU, "%llu");
PPRINT_ARRAY(xcpu_softirq, GLIBTOP_NCPU, "%llu");
PPRINT(xcpu_flags, "%llx");
FOOTER_PPRINT();
}
