void memory_cache_destroy (vmi_instance_t vmi)
{
uint32_t tmp = vmi->memory_cache_size_max;
vmi->memory_cache_size_max = 0;
clean_cache(vmi);
vmi->memory_cache_size_max = tmp;
}
int main (int argc, char *argv []) {
int listen_fd, port;
int client_fd;
socklen_t socket_length;
struct sockaddr_in client_socket;
pthread_mutex_init(&mutex_lock, NULL);
init_cache();
Signal (SIGPIPE, SIG_IGN);
if (argc != 2) {
fprintf(stderr, "usage: %s <port>\n", argv[0]);
exit(0);
}
port = atoi(argv[1]);
listen_fd = Open_listenfd(port);
socket_length = sizeof(client_socket);
while (1) {
client_fd = Accept(listen_fd, (SA*)&client_socket, &socket_length);
scheduler(client_fd);
}
pthread_mutex_destroy(&mutex_lock);
clean_cache();
}
static memory_cache_entry_t create_new_entry (vmi_instance_t vmi, addr_t paddr, uint32_t length)
{
// sanity check - are we getting memory outside of the physical memory range?
//
// This does not work with a Xen PV VM during page table lookups, because
// cr3 > [physical memory size]. It *might* not work when examining a PV
// snapshot, since we're not sure where the page tables end up. So, we
// just do it for a HVM guest.
//
// TODO: perform other reasonable checks
if (vmi->hvm && (paddr + length - 1 > vmi->size)) {
errprint ("--requesting PA [0x%llx] beyond memsize [0x%llx]\n",
paddr + length, vmi->size);
errprint ("\tpaddr: %llx, length %llx, vmi->size %llx\n",
paddr, length, vmi->size);
return 0;
}
memory_cache_entry_t entry =
(memory_cache_entry_t) safe_malloc(sizeof(struct memory_cache_entry));
entry->paddr = paddr;
entry->length = length;
entry->last_updated = time(NULL);
entry->last_used = entry->last_updated;
entry->data = get_memory_data(vmi, paddr, length);
if (vmi->memory_cache_size >= vmi->memory_cache_size_max){
clean_cache(vmi);
}
return entry;
}
void game_cache_options::clean_cache_callback()
{
if(clean_cache()) {
show_message(
_("Cache Cleaned"),
_("The game data cache has been cleaned."));
} else {
show_error_message(_("The game data cache could not be completely cleaned."));
}
update_cache_size_display();
}
void cleanup(int sig)//cleans up the queue once the server is done
{
printf("\nperforming cleanup and then exiting\n");
free(queue);
free(workers);
free(dispatcher);
if (use_cache) {
clean_cache();
free(cache);
}
free(log_file);
close(logFd);
pthread_mutex_destroy(&log_access);
pthread_mutex_destroy(&queue_access);
pthread_mutex_destroy(&threadnum_access);
exit(0);
}
void nand_demo() {
int (*OS_Entry)(void *);
unsigned int offset;
int blockno;
int blockstart;
int blockend;
int page;
enable_nand();
blockstart=0x20000/0x4000;
blockend=blockstart+(0x170000/0x4000);
offset=0x31000000;
for(blockno=blockstart;blockno<(blockend+1);blockno++) {
for(page=0;page<32;page++) {
NAND_ReadPage(blockno,page,offset);
offset = offset + 512;
}
}
clean_cache();
putstr("OS read successfully\r\n");
putstr("Press any key to continue\r\n");
getchar();
OS_Entry=(int *)0x31000000;
OS_Entry(1);
}
int main (int argc, char *argv []) {
int listen_fd, port;
int client_fd;
int i;
pthread_t tid;
socklen_t socket_length;
struct sockaddr_in client_socket;
pthread_mutex_init(&mutex_lock, NULL);
init_cache();
if (argc != 2) {
fprintf(stderr, "usage: %s <port>\n", argv[0]);
exit(0);
}
port = atoi(argv[1]);
socket_length = sizeof(client_socket);
/* ignore SIGPIPE */
Signal(SIGPIPE, SIG_IGN);
/* initialize worker thread, then initialize buffer
* for producer-consumer model */
sbuf_init(&sbuf, SBUFSIZE);
for (i = 0; i < NTHREADS; i++)
Pthread_create(&tid, NULL, worker_thread, NULL);
listen_fd = Open_listenfd(port);
while (1) {
client_fd = Accept(listen_fd, (SA*)&client_socket, &socket_length);
sbuf_insert(&sbuf, client_fd);
}
pthread_mutex_destroy(&mutex_lock);
clean_cache();
}
void free_cache(CACHE *cache) {
clean_cache(cache);
free(cache);
}
int
main(int argc, char *argv[])
{
uint8_t updb_all;
uint8_t do_inst = DO_INST; /* by default, do install packages */
int ch, rc = EXIT_SUCCESS;
struct stat sb;
const char *chrootpath = NULL;
setprogname(argv[0]);
if (argc < 2 || *argv[1] == 'h')
usage();
while ((ch = getopt(argc, argv, "dhyfFPvVl:nc:t:")) != -1) {
switch (ch) {
case 'f':
force_update = 1;
break;
case 'F':
force_reinstall = 1;
break;
case 'y':
yesflag = 1;
noflag = 0;
break;
case 'n':
yesflag = 0;
noflag = 1;
break;
case 'v':
printf("%s %s (using %s)\n",
getprogname(), PKGIN_VERSION, pdb_version());
exit(EXIT_SUCCESS);
/* NOTREACHED */
case 'h':
usage();
/* NOTREACHED */
case 'l':
lslimit = optarg[0];
break;
case 'd':
do_inst = DONT_INST; /* download only */
break;
case 'c':
chrootpath = optarg;
break;
case 'V':
verbosity = 1;
break;
case 'P':
package_version = 1;
break;
case 't':
if ((tracefp = fopen(optarg, "w")) == NULL)
err(EXIT_FAILURE, MSG_CANT_OPEN_WRITE, optarg);
break;
default:
usage();
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
fprintf(stderr, MSG_MISSING_CMD);
usage();
/* NOTREACHED */
}
/* initializations */
/* enter chroot if -c specified */
if (chrootpath != NULL) {
if (chroot(chrootpath) == -1)
errx(-1, MSG_CHROOT_FAILED);
if (chdir("/") == -1)
errx(-1, MSG_CHDIR_FAILED);
}
/* check for pkg_install */
if (stat(PKG_ADD, &sb) < 0)
errx(EXIT_FAILURE, MSG_PKG_INSTALL_NOT_PRESENT);
/* for pkg_install */
unsetenv("PKG_PATH");
/* create base directories */
if (stat(pkgin_cache, &sb) < 0)
create_dirs();
pkgindb_init();
/* check if current database fits our needs */
updb_all = upgrade_database();
/* update local db if pkgdb mtime has changed */
(void)update_db(LOCAL_SUMMARY, NULL);
/* split PKG_REPOS env variable and record them */
split_repos();
/*
* upgrade remote database if pkgin version changed and not compatible
* or if empty database
*/
if (updb_all)
(void)update_db(REMOTE_SUMMARY, NULL);
/* find command index */
ch = find_cmd(argv[0]);
/* we need packages lists for almost everything */
if (ch != PKG_UPDT_CMD) /* already loaded by update_db() */
init_global_pkglists();
/* fill pkgtools flags */
if (verbosity)
strncpy(pkgtools_flags, "-fv", 3);
else
strncpy(pkgtools_flags, "-f", 2);
switch (ch) {
case PKG_UPDT_CMD: /* update packages db */
if (update_db(REMOTE_SUMMARY, NULL) == EXIT_FAILURE)
errx(EXIT_FAILURE, MSG_DONT_HAVE_RIGHTS);
break;
case PKG_SHDDP_CMD: /* show direct depends */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
rc = show_direct_depends(argv[1]);
break;
case PKG_SHFDP_CMD: /* show full dependency tree */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
rc = show_full_dep_tree(argv[1],
DIRECT_DEPS, MSG_FULLDEPTREE);
break;
case PKG_SHRDP_CMD: /* show full reverse dependency tree */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
rc = show_full_dep_tree(argv[1],
LOCAL_REVERSE_DEPS,
MSG_REVDEPTREE);
break;
case PKG_LLIST_CMD:
/* list local packages */
list_pkgs(LOCAL_PKGS_QUERY_DESC, PKG_LLIST_CMD);
break;
case PKG_RLIST_CMD:
/* list available packages */
list_pkgs(REMOTE_PKGS_QUERY_DESC, PKG_RLIST_CMD);
break;
case PKG_INST_CMD: /* install a package and its dependencies */
missing_param(argc, 2, MSG_PKG_ARGS_INST);
pkgin_install(&argv[1], do_inst);
break;
case PKG_UPGRD_CMD: /* upgrade keep-packages */
pkgin_upgrade(UPGRADE_KEEP);
break;
case PKG_FUPGRD_CMD: /* upgrade everything installed */
pkgin_upgrade(UPGRADE_ALL);
break;
case PKG_REMV_CMD: /* remove packages and reverse dependencies */
missing_param(argc, 2, MSG_PKG_ARGS_RM);
pkgin_remove(&argv[1]);
break;
case PKG_AUTORM_CMD: /* autoremove orphan packages */
pkgin_autoremove();
break;
case PKG_KEEP_CMD: /* mark a package as "keep" (not automatic) */
missing_param(argc, 2, MSG_PKG_ARGS_KEEP);
pkg_keep(KEEP, &argv[1]);
break;
case PKG_UNKEEP_CMD: /* mark a package as "unkeep" (automatic) */
missing_param(argc, 2, MSG_PKG_ARGS_UNKEEP);
pkg_keep(UNKEEP, &argv[1]);
break;
case PKG_SHKP_CMD: /* show keep packages */
show_pkg_keep();
break;
case PKG_SRCH_CMD: /* search for package */
missing_param(argc, 2, MSG_MISSING_SRCH);
search_pkg(argv[1]);
break;
case PKG_CLEAN_CMD: /* clean pkgin's packages cache */
clean_cache();
break;
case PKG_EXPORT_CMD: /* export PKGPATH for keep packages */
export_keep();
break;
case PKG_IMPORT_CMD: /* import for keep packages and install them */
missing_param(argc, 2, MSG_MISSING_FILENAME);
import_keep(do_inst, argv[1]);
break;
case PKG_SHPROV_CMD: /* show what a package provides */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_prov_req(GET_PROVIDES_QUERY, argv[1]);
break;
case PKG_SHREQ_CMD: /* show what a package requires */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_prov_req(GET_REQUIRES_QUERY, argv[1]);
break;
case PKG_SHPKGCONT_CMD: /* show remote package content */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_pkg_info('L', argv[1]); /* pkg_info flag */
break;
case PKG_SHPKGDESC_CMD: /* show remote package DESCR */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_pkg_info('d', argv[1]); /* pkg_info flag */
break;
case PKG_SHPKGBDEFS_CMD: /* show remote package build definitions */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_pkg_info('B', argv[1]); /* pkg_info flag */
break;
case PKG_GINTO_CMD: /* Miod's request */
ginto();
break;
default:
usage();
/* NOTREACHED */
}
free_global_pkglists();
pkgindb_close();
if (tracefp != NULL)
fclose(tracefp);
XFREE(env_repos);
XFREE(pkg_repos);
return rc;
}
int bunsan_pm_repository_clean_cache(bunsan_pm_repository repo,
string error_msg, size_type error_size) {
const auto r = static_cast<bunsan::pm::compatibility::repository *>(repo);
BOOST_ASSERT(r);
return wrap_cpp([&] { r->clean_cache(); }, error_msg, error_size);
}
