cube cube::operator + (const cube &h) const { cube H = {x+h.x,y+h.y,z+h.z}; if (distance(H) > get_map_size()) { int S = get_map_size(); if (distance(H,cube{2*S+1, -S, -S-1}) <= S) { H = cube_subtract(H,cube{2*S+1, -S, -S-1}); } else if (distance(H,cube{S+1, -2*S-1, S}) <= S) { H = cube_subtract(H,cube{S+1, -2*S-1, S}); } else if (distance(H,cube{-S, -S-1, 2*S+1}) <= S) { H = cube_subtract(H,cube{-S, -S-1, 2*S+1}); } else if (distance(H,cube{-2*S-1, S, S+1}) <= S) { H = cube_subtract(H,cube{-2*S-1, S, S+1}); } else if (distance(H,cube{-S-1, 2*S+1, -S}) <= S) { H = cube_subtract(H,cube{-S-1, 2*S+1, -S}); } else if (distance(H,cube{S, S+1, -2*S-1}) <= S) { H = cube_subtract(H,cube{S, S+1, -2*S-1}); } } return H; }
static int pcap_mmap_prepare_writing_pcap(int fd) { int ret; struct stat sb; spinlock_lock(&lock); map_size = get_map_size(); ret = fstat(fd, &sb); if (ret < 0) panic("Cannot fstat pcap file!\n"); if (!S_ISREG (sb.st_mode)) panic("pcap dump file is not a regular file!\n"); /* Expand file buffer, so that mmap can be done. */ ret = lseek(fd, map_size, SEEK_SET); if (ret < 0) panic("Cannot lseek pcap file!\n"); ret = write_or_die(fd, "", 1); if (ret != 1) panic("Cannot write file!\n"); pstart = mmap(0, map_size, PROT_WRITE, MAP_SHARED /*| MAP_HUGETLB*/, fd, 0); if (pstart == MAP_FAILED) puke_and_die(EXIT_FAILURE, "mmap of file failed!"); ret = madvise(pstart, map_size, MADV_SEQUENTIAL); if (ret < 0) panic("Failed to give kernel mmap advise!\n"); pcurr = pstart + sizeof(struct pcap_filehdr); spinlock_unlock(&lock); return 0; }
static gboolean invalidate_canvas (ChamplainPathLayer *layer) { ChamplainPathLayerPrivate *priv = layer->priv; gfloat view_width, view_height; gint map_width, map_height; gint viewport_x, viewport_y; gint anchor_x, anchor_y; gfloat right_actor_width, right_actor_height; gfloat left_actor_width, left_actor_height; right_actor_width = 256; right_actor_height = 256; left_actor_width = 0; left_actor_height = 0; map_width = 256; map_height = 256; if (priv->view != NULL) { get_map_size (priv->view, &map_width, &map_height); clutter_actor_get_size (CLUTTER_ACTOR (priv->view), &view_width, &view_height); champlain_view_get_viewport_origin (priv->view, &viewport_x, &viewport_y); champlain_view_get_viewport_anchor (priv->view, &anchor_x, &anchor_y); right_actor_width = MIN (map_width - (viewport_x + anchor_x), (gint)view_width); right_actor_height = MIN (map_height - (viewport_y + anchor_y), (gint)view_height); left_actor_width = MIN (view_width - right_actor_width, map_width - right_actor_width); left_actor_height = right_actor_height; /* Ensure sizes are positive */ right_actor_width = MAX (0, right_actor_width); right_actor_height = MAX (0, right_actor_height); left_actor_width = MAX (0, left_actor_width); left_actor_height = MAX (0, left_actor_height); } clutter_actor_set_size (priv->path_actor, map_width, map_height); clutter_actor_set_size (priv->right_actor, right_actor_width, right_actor_height); clutter_canvas_set_size (CLUTTER_CANVAS (priv->right_canvas), right_actor_width, right_actor_height); clutter_content_invalidate (priv->right_canvas); if (left_actor_width != 0) { clutter_actor_set_size (priv->left_actor, left_actor_width, left_actor_height); clutter_canvas_set_size (CLUTTER_CANVAS (priv->left_canvas), left_actor_width, left_actor_height); clutter_content_invalidate (priv->left_canvas); } priv->redraw_scheduled = FALSE; return FALSE; }
int main(void) { t_env env; get_map_size(&env, "map"); makeparams(&env); wolf(&env); mlx_hook(env.win, 2, (1L << 0), get_key_event, &env); mlx_loop(env.mlx); return (0); }
static int fusecow_truncate(const char *path, off64_t size) { (void) size; if(strcmp(path, "/") != 0) return -ENOENT; st_size = size; munmap(mem_write_map, mem_write_map_size); mem_write_map_size = get_map_size(); ftruncate(fd_write_map, mem_write_map_size); pwrite64(fd_write_map, &st_size, sizeof st_size, 8); mem_write_map = mmap(NULL, mem_write_map_size , PROT_READ|PROT_WRITE, MAP_SHARED, fd_write_map, 0); if(ftruncate(fd_write, size)==-1) { return -errno; } return 0; }
int main(int argc, char *argv[]) { int ret,i; char* argv2[argc-1+2]; // File name removed, "-o nonempty,direct_io" added int our_arguments_count=5; /* argv[0], source file, storage file and mount point */ block_size=8192; fd=0; fd_write=0; fd_write_map=0; mem_write_map=MAP_FAILED; fd_read=0; fd_read_map=0; mem_read_map=MAP_FAILED; read_only = 0; int block_size_overridden=0; if(argc<4){ fprintf(stderr,"fusecoraw alpha version. Copy-on-read-and-write block device using FUSE and sparse files. Fusecow originally created by _Vi, altered to fusecoraw by EvdH.\n"); fprintf(stderr,"Usage: %s read_file mountpoint_file write_file read_file [-RM read_file.map] [-WM write_file.map] [-B blocksize] [-RO (read-only, for remounting)] [FUSE_options]\n",argv[0]); fprintf(stderr,"Examples:\n"); fprintf(stderr," fusecoraw source mountpoint copy-on-write-fle copy-on-read-file\n"); fprintf(stderr,"Remember to \"touch\" your mountpoints, not \"mkdir\" them.\n"); return 1; } { char write_mapfile_buff[4096]; sprintf(write_mapfile_buff, "%s.map", argv[3]); const char *write_mapfile = write_mapfile_buff; char read_mapfile_buff[4096]; sprintf(read_mapfile_buff, "%s.map", argv[4]); const char *read_mapfile = read_mapfile_buff; for(;argv[our_arguments_count];) { if(!strcmp(argv[our_arguments_count], "-B")) { ++our_arguments_count; sscanf(argv[our_arguments_count], "%i", &block_size); block_size_overridden = 1; ++our_arguments_count; } else if(!strcmp(argv[our_arguments_count], "-WM")) { ++our_arguments_count; write_mapfile = argv[our_arguments_count]; ++our_arguments_count; } else if(!strcmp(argv[our_arguments_count], "-RM")) { ++our_arguments_count; read_mapfile = argv[our_arguments_count]; ++our_arguments_count; } else if(!strcmp(argv[our_arguments_count], "-RO")) { ++our_arguments_count; read_only = 1; } else { break; } } fd=open64(argv[1],O_RDONLY); if(fd<0){ fprintf(stderr, "Unable to open read file \"%s\"\n", argv[1]); perror("open"); return 1; } fd_write=open64(argv[3], O_RDWR|O_CREAT, 0777); if(fd_write<0){ fprintf(stderr, "Unable to open write file \"%s\"\n", argv[3]); perror("open"); return 1; } fd_write_map=open(write_mapfile, O_RDWR|O_CREAT, 0777); if(fd_write_map<0){ fprintf(stderr, "Unable to open map file \"%s\"\n", write_mapfile); perror("open"); return 1; } if(read_only) fd_read=open64(argv[4], O_RDONLY, 0777); else fd_read=open64(argv[4], O_RDWR|O_CREAT, 0777); if(fd_read<0){ fprintf(stderr, "Unable to open read file \"%s\"\n", argv[4]); perror("open"); return 1; } if(read_only) fd_read_map=open(read_mapfile, O_RDONLY, 0777); else fd_read_map=open(read_mapfile, O_RDWR|O_CREAT, 0777); if(fd_read_map<0){ fprintf(stderr, "Unable to open read map file \"%s\"\n", read_mapfile); perror("open"); return 1; } char write_signature[8]; write_signature[0]=0; pread64(fd_write_map, &write_signature, sizeof write_signature, 0); write_signature[7]=0; if (strcmp(write_signature, "fusecow")) { // No signature: struct stat stbuf; fstat(fd, &stbuf); stbuf.st_size = st_size = (off64_t)lseek64(fd, (off64_t)0, SEEK_END); pwrite64(fd_write_map, "fusecow\n", 8, 0); pwrite64(fd_write_map, &st_size, sizeof st_size, 8); pwrite64(fd_write_map, &block_size, sizeof block_size, 16); // Actual data begins at offset 32 } else { pread64(fd_write_map, &st_size, sizeof st_size, 8); int blocksize; pread64(fd_write_map, &blocksize, sizeof block_size, 16); if(block_size_overridden && blocksize!=block_size) { fprintf(stderr, "Your block size %d and block size %d saved in \"%s\" is not the same\nI will use saved block size anyway\n", block_size, blocksize, write_mapfile); // return 1; } block_size = blocksize; } char read_signature[8]; read_signature[0]=0; pread64(fd_read_map, &read_signature, sizeof read_signature, 0); read_signature[7]=0; if (strcmp(read_signature, "fusecow")) { // No signature: struct stat stbuf; fstat(fd, &stbuf); stbuf.st_size = st_size = (off64_t)lseek64(fd, (off64_t)0, SEEK_END); pwrite64(fd_read_map, "fusecow\n", 8, 0); pwrite64(fd_read_map, &st_size, sizeof st_size, 8); pwrite64(fd_read_map, &block_size, sizeof block_size, 16); // Actual data begins at offset 32 } else { pread64(fd_read_map, &st_size, sizeof st_size, 8); int blocksize; pread64(fd_read_map, &blocksize, sizeof block_size, 16); if(block_size_overridden && blocksize!=block_size) { fprintf(stderr, "Your block size %d and block size %d saved in \"%s\" is not the same\nI will use saved block size anyway\n", block_size, blocksize, read_mapfile); // return 1; } block_size = blocksize; } mem_write_map_size = get_map_size(); ftruncate(fd_write_map, mem_write_map_size); mem_write_map = mmap(NULL, mem_write_map_size , PROT_READ|PROT_WRITE, MAP_SHARED, fd_write_map, 0); if(mem_write_map==MAP_FAILED) { perror("mmap"); fprintf(stderr, "Unable to open memory mapping. Using simplified mode.\n"); } mem_read_map_size = get_map_size(); ftruncate(fd_read_map, mem_read_map_size); if(!read_only){ mem_read_map = mmap(NULL, mem_read_map_size , PROT_READ|PROT_WRITE, MAP_SHARED, fd_read_map, 0); if(mem_read_map==MAP_FAILED) { perror("mmap"); fprintf(stderr, "Unable to open memory mapping. Using simplified mode.\n"); } } } copyup_buffer = (char*) malloc(block_size); int argc2=0; argv2[argc2++]=argv[0]; argv2[argc2++]=argv[2]; // mount point file for(i=our_arguments_count;i<argc;++i)argv2[argc2++]=argv[i]; argv2[argc2++]="-o"; argv2[argc2++]="nonempty,direct_io"; argv2[argc2]=0; ret=fuse_main(argc2, argv2, &fusecow_oper, NULL); close(fd); close(fd_write); close(fd_write_map); close(fd_read); close(fd_read_map); munmap(mem_write_map, mem_write_map_size); munmap(mem_read_map, mem_read_map_size); free(copyup_buffer); return ret; }
/* Fonction exécutée par un thread. */ void *watch_sockets(void *useless) { u_int i,size, i_fd ; int nb_readable = 0 ; struct pollfd *socket_set; int timeout = 1000; /* timeout (1s) pour poll, afin de régulièrement remettre les sockets dans l'ensemble */ useless=useless; /* Initialisation. */ socket_set = (struct pollfd*) malloc(sizeof(struct pollfd)*N_SOCK) ; size = get_map_size(socket_map) ; for(i = 0 ; i < N_SOCK ; i++) { socket_set[i].events = POLLIN ; socket_set[i].revents = 0 ; } for(i = 0 ; i < size ; i++) socket_set[i].fd = (int) get_id(socket_map,i) ; for(i = size ; i < N_SOCK ; i++) socket_set[i].fd = -1 ; /* pas de socket pour l'instant */ /* Boucle d'écoute */ while(!quit_program) { if((nb_readable=poll(socket_set,size,timeout))<0) { perror("poll"); exit(errno) ; } /* On réactive les sockets de handled_request */ pthread_mutex_lock(&handled_request->lock) ; while(handled_request->first != handled_request->last) { i_fd = get_name(socket_map,(u_int)handled_request->queue[handled_request->first]) ; size = get_map_size(socket_map) ; /* peut être de nouvelles sockets */ assert(socket_set[i_fd].fd < 0) ; socket_set[i_fd].fd = handled_request->queue[handled_request->first] ; handled_request->first ++ ; } pthread_mutex_unlock(&handled_request->lock) ; /* On place dans request toutes les sockets avec un message en attente. */ if(nb_readable == 0) continue ; if(VERBOSE) { pthread_mutex_lock(&print_lock) ; green(); printf("[Watching thread]\t"); blue(); printf("There is %d additional readable socket(s).\n",nb_readable) ; normal(); pthread_mutex_unlock(&print_lock) ; } pthread_mutex_lock(&request->lock) ; for(i = 0 ; i < size ; i++) { if(socket_set[i].revents != 0) { /* un événement ! */ assert(socket_set[i].fd > 0) ; request->queue[request->last] = socket_set[i].fd ; request->last = (request->last+1)%N_SOCK ; if(sem_post(&request->full) < 0) { /* signal sur la semaphore */ perror("sem_post"); exit(errno) ; } socket_set[i].fd = -1 ; /* desactive la surveillance sur cette socket */ } } pthread_mutex_unlock(&request->lock) ; } pthread_mutex_lock(&print_lock) ; green(); printf("[Watching thread]\t"); normal(); printf("will quit.\n") ; pthread_mutex_unlock(&print_lock) ; for(i = 0 ; i < N_THREAD ; i++) { if(sem_post(&request->full) < 0) { /* signal sur la semaphore */ perror("sem_post"); exit(errno) ; } } free(socket_set); pthread_exit(useless); }