// *************************************************************************************************
// @fn main
// @brief Main routine
// @param none
// @return none
// *************************************************************************************************
int main(void)
{
#ifdef EMU
emu_init();
#endif
// Init MCU
init_application();
// Assign initial value to global variables
init_global_variables();
#ifdef CONFIG_TEST
// Branch to welcome screen
test_mode();
#else
display_all_off();
#endif
// Main control loop: wait in low power mode until some event needs to be processed
while(1)
{
// When idle go to LPM3
idle_loop();
// Process wake-up events
if (button.all_flags || sys.all_flags) wakeup_event();
// Process actions requested by logic modules
if (request.all_flags) process_requests();
// Before going to LPM3, update display
if (display.all_flags) display_update();
}
}
int main(int argc, char *argv[])
{
info("testing field functions");
if (test_field() < 0)
return 1;
info("testing mode functions");
if (test_mode() < 0)
return 1;
info("testing regime functions");
if (test_regime() < 0)
return 1;
info("testing program functions");
if (test_program() < 0)
return 1;
info("testing learning_data functions");
if (test_learning_data() < 0)
return 1;
printf("completed with %d failure(s) and %d error(s)\n",
num_failures, num_errors);
return num_failures;
}
int main(int argc, char** argv)
{
printf("KEY META TESTS\n");
printf("==================\n\n");
init (argc, argv);
test_basic();
test_iterate();
test_size();
test_uid();
test_dup();
test_comment();
test_owner();
test_mode();
test_type();
test_examples();
test_copy();
test_ro();
test_new();
test_copyall();
printf("\ntest_ks RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError);
return nbError;
}
/***************************************************************************
************************ ENTRYPOINT AND MAIN LOOP *************************
**************************************************************************/
int main(void)
{
// Init MCU
init_application();
#ifdef CONFIG_TEST
// Branch to welcome screen
test_mode();
#else
/* clear whole scren */
display_clear(0, 0);
#endif
/* Init modules */
mod_init();
/* main loop */
while (1) {
/* Go to LPM3, wait for interrupts */
_BIS_SR(LPM3_bits + GIE);
__no_operation();
/* service watchdog on wakeup */
#ifdef USE_WATCHDOG
// Service watchdog (reset counter)
WDTCTL = (WDTCTL & 0xff) | WDTPW | WDTCNTCL;
#endif
/* check if any driver has events pending */
check_events();
/* check for button presses, drive the menu */
check_buttons();
}
}
/*-----------------------------------------------------------------
* The standard io loop that keeps submitting an io until it's
* all gone.
*---------------------------------------------------------------*/
static int _io(struct device_area *where, char *buffer, int should_write)
{
int fd = dev_fd(where->dev);
ssize_t n = 0;
size_t total = 0;
if (fd < 0) {
log_error("Attempt to read an unopened device (%s).",
dev_name(where->dev));
return 0;
}
/*
* Skip all writes in test mode.
*/
if (should_write && test_mode())
return 1;
if (where->size > SSIZE_MAX) {
log_error("Read size too large: %" PRIu64, where->size);
return 0;
}
if (lseek(fd, (off_t) where->start, SEEK_SET) < 0) {
log_error("%s: lseek %" PRIu64 " failed: %s",
dev_name(where->dev), (uint64_t) where->start,
strerror(errno));
return 0;
}
while (total < (size_t) where->size) {
do
n = should_write ?
write(fd, buffer, (size_t) where->size - total) :
read(fd, buffer, (size_t) where->size - total);
while ((n < 0) && ((errno == EINTR) || (errno == EAGAIN)));
if (n < 0)
log_error_once("%s: %s failed after %" PRIu64 " of %" PRIu64
" at %" PRIu64 ": %s", dev_name(where->dev),
should_write ? "write" : "read",
(uint64_t) total,
(uint64_t) where->size,
(uint64_t) where->start, strerror(errno));
if (n <= 0)
break;
total += n;
buffer += n;
}
return (total == (size_t) where->size);
}
//Call this function for controlling the robot manually
void inherent_function(void)
{
ADC_update();
if(!SW_IN_2 && !SW_IN_1) //enter the line following mode when button S5 and S6 are pressed together
{
while(!SW_IN_2 || !SW_IN_1)
{
test_mode();
}
}
else if(!SW_IN_1) //enter the manual control mode when button S6 is pressed
{
while(!SW_IN_1);
test_mode();
}
}
int
main ()
{
int ret;
/* Create a file with some contents. */
{
FILE *fp;
fp = fopen (TESTFILE, "w");
if (fp == NULL)
goto skip;
if (fwrite ("foobarsh", 1, 8, fp) < 8)
goto skip;
if (fclose (fp))
goto skip;
}
ret = test_mode (_IONBF);
if (ret != 0)
goto fail;
ret = test_mode (_IOLBF);
if (ret != 0)
goto fail;
ret = test_mode (_IOFBF);
if (ret != 0)
goto fail;
return 0;
fail:
return ret;
skip:
fprintf (stderr, "Skipping test: file operations failed.\n");
return 77;
}
int
main(int argc, char* argv[])
{
file_info(STDIN_FILENO);
file_info(STDOUT_FILENO);
test_access();
test_faccessat();
test_mode();
test_chown();
test_write_test();
test_unlink();
test_link();
test_mkdir();
test_readdir();
test_openat();
test_ln();
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
monome_t *monome;
int i;
i =0;
if( !(monome = monome_open((argc == 2 ) ? argv[1] : DEFAULT_MONOME_DEVICE, "8000")) )
return -1;
test_led_ring_set(monome);
return 0;
monome_led_all(monome, 0);
for( i = 0; i < 2; i++ ) {
test_led_row_8(monome, 1);
test_led_col_8(monome, 1);
}
for( i = 0; i < 2; i++ ) {
test_led_row_16(monome, 1);
test_led_col_16(monome, 1);
}
test_led_col_16(monome, 0);
test_led_on_off(monome);
test_led_map(monome);
chill(4);
test_mode(monome);
fade_out(monome);
monome_led_all(monome, 0);
monome_led_intensity(monome, 0x0F);
return 0;
}
static int _lock_for_cluster(struct cmd_context *cmd, unsigned char clvmd_cmd,
uint32_t flags, const char *name)
{
int status;
int i;
char *args;
const char *node = "";
int len;
int dmeventd_mode;
int saved_errno;
lvm_response_t *response = NULL;
int num_responses;
assert(name);
len = strlen(name) + 3;
args = alloca(len);
strcpy(args + 2, name);
/* args[0] holds bottom 8 bits except LCK_LOCAL (0x40). */
args[0] = flags & (LCK_SCOPE_MASK | LCK_TYPE_MASK | LCK_NONBLOCK | LCK_HOLD | LCK_CLUSTER_VG);
args[1] = 0;
if (flags & LCK_ORIGIN_ONLY)
args[1] |= LCK_ORIGIN_ONLY_MODE;
if (flags & LCK_REVERT)
args[1] |= LCK_REVERT_MODE;
if (mirror_in_sync())
args[1] |= LCK_MIRROR_NOSYNC_MODE;
if (test_mode())
args[1] |= LCK_TEST_MODE;
/*
* We propagate dmeventd_monitor_mode() to clvmd faithfully, since
* dmeventd monitoring is tied to activation which happens inside clvmd
* when locking_type = 3.
*/
dmeventd_mode = dmeventd_monitor_mode();
if (dmeventd_mode == DMEVENTD_MONITOR_IGNORE)
args[1] |= LCK_DMEVENTD_MONITOR_IGNORE;
if (dmeventd_mode)
args[1] |= LCK_DMEVENTD_MONITOR_MODE;
if (cmd->partial_activation)
args[1] |= LCK_PARTIAL_MODE;
/*
* VG locks are just that: locks, and have no side effects
* so we only need to do them on the local node because all
* locks are cluster-wide.
*
* P_ locks /do/ get distributed across the cluster because they might
* have side-effects.
*
* SYNC_NAMES and VG_BACKUP use the VG name directly without prefix.
*/
if (clvmd_cmd == CLVMD_CMD_SYNC_NAMES) {
if (flags & LCK_LOCAL)
node = NODE_LOCAL;
} else if (clvmd_cmd != CLVMD_CMD_VG_BACKUP) {
if (strncmp(name, "P_", 2) &&
(clvmd_cmd == CLVMD_CMD_LOCK_VG ||
(flags & LCK_LOCAL) ||
!(flags & LCK_CLUSTER_VG)))
node = NODE_LOCAL;
else if (flags & LCK_REMOTE)
node = NODE_REMOTE;
}
status = _cluster_request(clvmd_cmd, node, args, len,
&response, &num_responses);
/* If any nodes were down then display them and return an error */
for (i = 0; i < num_responses; i++) {
if (response[i].status == EHOSTDOWN) {
log_error("clvmd not running on node %s",
response[i].node);
status = 0;
errno = response[i].status;
} else if (response[i].status) {
log_error("Error locking on node %s: %s",
response[i].node,
response[i].response[0] ?
response[i].response :
strerror(response[i].status));
status = 0;
errno = response[i].status;
}
}
saved_errno = errno;
_cluster_free_request(response, num_responses);
errno = saved_errno;
return status;
}
int test_unop(Shell_t *shp,register int op,register const char *arg)
{
struct stat statb;
int f;
switch(op)
{
case 'r':
return(permission(arg, R_OK));
case 'w':
return(permission(arg, W_OK));
case 'x':
return(permission(arg, X_OK));
case 'V':
#if SHOPT_FS_3D
{
register int offset = staktell();
if(stat(arg,&statb)<0 || !S_ISREG(statb.st_mode))
return(0);
/* add trailing / */
stakputs(arg);
stakputc('/');
stakputc(0);
arg = (const char*)stakptr(offset);
stakseek(offset);
/* FALL THRU */
}
#else
return(0);
#endif /* SHOPT_FS_3D */
case 'd':
return(test_stat(arg,&statb)>=0 && S_ISDIR(statb.st_mode));
case 'c':
return(test_stat(arg,&statb)>=0 && S_ISCHR(statb.st_mode));
case 'b':
return(test_stat(arg,&statb)>=0 && S_ISBLK(statb.st_mode));
case 'f':
return(test_stat(arg,&statb)>=0 && S_ISREG(statb.st_mode));
case 'u':
return(test_mode(arg)&S_ISUID);
case 'g':
return(test_mode(arg)&S_ISGID);
case 'k':
#ifdef S_ISVTX
return(test_mode(arg)&S_ISVTX);
#else
return(0);
#endif /* S_ISVTX */
#if SHOPT_TEST_L
case 'l':
#endif
case 'L':
case 'h': /* undocumented, and hopefully will disappear */
if(*arg==0 || arg[strlen(arg)-1]=='/' || lstat(arg,&statb)<0)
return(0);
return(S_ISLNK(statb.st_mode));
case 'C':
#ifdef S_ISCTG
return(test_stat(arg,&statb)>=0 && S_ISCTG(statb.st_mode));
#else
return(0);
#endif /* S_ISCTG */
case 'H':
#ifdef S_ISCDF
{
register int offset = staktell();
if(test_stat(arg,&statb)>=0 && S_ISCDF(statb.st_mode))
return(1);
stakputs(arg);
stakputc('+');
stakputc(0);
arg = (const char*)stakptr(offset);
stakseek(offset);
return(test_stat(arg,&statb)>=0 && S_ISCDF(statb.st_mode));
}
#else
return(0);
#endif /* S_ISCDF */
case 'S':
return(isasock(arg,&statb));
case 'N':
return(test_stat(arg,&statb)>=0 && tmxgetmtime(&statb) > tmxgetatime(&statb));
case 'p':
return(isapipe(arg,&statb));
case 'n':
return(*arg != 0);
case 'z':
return(*arg == 0);
case 's':
sfsync(sfstdout);
case 'O':
case 'G':
if(*arg==0 || test_stat(arg,&statb)<0)
return(0);
if(op=='s')
return(statb.st_size>0);
else if(op=='O')
return(statb.st_uid==shp->gd->userid);
return(statb.st_gid==shp->gd->groupid);
case 'a':
case 'e':
if(memcmp(arg,"/dev/",5)==0 && sh_open(arg,O_NONBLOCK))
return(1);
return(permission(arg, F_OK));
case 'o':
f=1;
if(*arg=='?')
return(sh_lookopt(arg+1,&f)>0);
op = sh_lookopt(arg,&f);
return(op && (f==(sh_isoption(op)!=0)));
case 't':
{
char *last;
op = strtol(arg,&last, 10);
return(*last?0:tty_check(op));
}
case 'v':
case 'R':
{
Namval_t *np;
Namarr_t *ap;
int isref;
if(!(np = nv_open(arg,shp->var_tree,NV_VARNAME|NV_NOFAIL|NV_NOADD|NV_NOREF)))
return(0);
isref = nv_isref(np);
if(op=='R')
return(isref);
if(isref)
{
if(np->nvalue.cp)
np = nv_refnode(np);
else
return(0);
}
if(ap = nv_arrayptr(np))
return(nv_arrayisset(np,ap));
return(!nv_isnull(np) || nv_isattr(np,NV_INTEGER));
}
default:
{
static char a[3] = "-?";
a[1]= op;
errormsg(SH_DICT,ERROR_exit(2),e_badop,a);
/* NOTREACHED */
return(0);
}
}
}
static int _vgrename_single(struct cmd_context *cmd, const char *vg_name,
struct volume_group *vg, struct processing_handle *handle)
{
struct vgrename_params *vp = (struct vgrename_params *) handle->custom_handle;
struct lvmcache_vginfo *vginfo;
char old_path[NAME_LEN];
char new_path[NAME_LEN];
struct id id;
const char *name;
char *dev_dir;
/*
* vg_name_old may be a UUID which process_each_vg
* replaced with the real VG name. In that case,
* vp->vg_name_old will be the UUID and vg_name will be
* the actual VG name. Check again if the old and new
* names match, using the real names.
*/
if (vp->old_name_is_uuid && !strcmp(vp->vg_name_new, vg_name)) {
log_error("New VG name must differ from the old VG name.");
return ECMD_FAILED;
}
/*
* Check if a VG already exists with the new VG name.
*
* When not using lvmetad, it's essential that a full scan has
* been done to ensure we see all existing VG names, so we
* do not use an existing name. This has been done by
* process_each_vg REQUIRES_FULL_LABEL_SCAN.
*
* (FIXME: We could look for the new name in the list of all
* VGs that process_each_vg created, but we don't have access
* to that list here, so we have to look in lvmcache.
* This requires populating lvmcache when using lvmetad.)
*/
lvmcache_seed_infos_from_lvmetad(cmd);
if ((vginfo = lvmcache_vginfo_from_vgname(vp->vg_name_new, NULL))) {
log_error("New VG name \"%s\" already exists", vp->vg_name_new);
return ECMD_FAILED;
}
if (id_read_format_try(&id, vp->vg_name_new) &&
(name = lvmcache_vgname_from_vgid(cmd->mem, (const char *)&id))) {
log_error("New VG name \"%s\" matches the UUID of existing VG %s", vp->vg_name_new, name);
return ECMD_FAILED;
}
/*
* Lock the old VG name first:
* . The old VG name has already been locked by process_each_vg.
* . Now lock the new VG name here, second.
*
* Lock the new VG name first:
* . The new VG name has already been pre-locked below,
* before process_each_vg was called.
* . process_each_vg then locked the old VG name second.
* . Nothing to do here.
*
* Special case when the old VG name is a uuid:
* . The old VG's real name wasn't known before process_each_vg,
* so the correct lock ordering wasn't known beforehand,
* so no pre-locking was done.
* . The old VG's real name has been locked by process_each_vg.
* . Now lock the new VG name here, second.
* . Suppress lock ordering checks because the lock order may
* have wanted the new name first, which wasn't possible in
* this uuid-for-name case.
*/
if (vp->lock_vg_old_first || vp->old_name_is_uuid) {
if (vp->old_name_is_uuid)
lvmcache_lock_ordering(0);
if (!_lock_new_vg_for_rename(cmd, vp->vg_name_new))
return ECMD_FAILED;
lvmcache_lock_ordering(1);
}
dev_dir = cmd->dev_dir;
if (!archive(vg))
goto error;
/* Remove references based on old name */
if (!drop_cached_metadata(vg))
stack;
if (!lockd_rename_vg_before(cmd, vg)) {
stack;
goto error;
}
/* Change the volume group name */
vg_rename(cmd, vg, vp->vg_name_new);
/* store it on disks */
log_verbose("Writing out updated volume group");
if (!vg_write(vg) || !vg_commit(vg)) {
goto error;
}
sprintf(old_path, "%s%s", dev_dir, vg_name);
sprintf(new_path, "%s%s", dev_dir, vp->vg_name_new);
if (activation() && dir_exists(old_path)) {
log_verbose("Renaming \"%s\" to \"%s\"", old_path, new_path);
if (test_mode())
log_verbose("Test mode: Skipping rename.");
else if (lvs_in_vg_activated(vg)) {
if (!vg_refresh_visible(cmd, vg)) {
log_error("Renaming \"%s\" to \"%s\" failed",
old_path, new_path);
goto error;
}
}
}
lockd_rename_vg_final(cmd, vg, 1);
if (!backup(vg))
stack;
if (!backup_remove(cmd, vg_name))
stack;
unlock_vg(cmd, vp->vg_name_new);
vp->unlock_new_name = 0;
log_print_unless_silent("Volume group \"%s\" successfully renamed to \"%s\"",
vp->vg_name_old, vp->vg_name_new);
return 1;
error:
unlock_vg(cmd, vp->vg_name_new);
vp->unlock_new_name = 0;
lockd_rename_vg_final(cmd, vg, 0);
return 0;
}
