int main(int argc, char** argv) { int i; test_reallocate(); { deque_t d; int lots = 2; deque_init(4, &d, 0); push_front_counting(4, &d, lots); //print_deque(4, &d); pop_back_check_counting(4, &d, lots); //print_deque(4, &d); check_empty(4, &d); deque_destroy(&d); } for( i = 0; i < 32; i++ ) { test_deque(i); } for( i = 127; i < 512; i++ ) { test_deque(i); } test_deque(1 << 15); printf("deque_test PASS\n"); return 0; }
double check_sync(OSyncEngine *engine, const char *name, int num) { int ret; printf("."); fflush(stdout); starttime = _second(); osync_trace(TRACE_INTERNAL, "++++++++++++++++ Test \"%s %i\" starting ++++++++++++++", name, num); osengine_set_enginestatus_callback(engine, engine_status, NULL); sync_now(engine); osengine_set_enginestatus_callback(engine, NULL, NULL); int wasted = 0; int alldeciders = 0; osengine_get_wasted(engine, &alldeciders, &wasted); osync_trace(TRACE_INTERNAL, "++++++++++++++++ Test \"%s %i\" ended (%i / %i (%i%%)) ++++++++++++++", name, num, wasted, alldeciders, (int)(((float)wasted / (float)alldeciders) * 100)); double thistime = _second() - starttime; printf("."); fflush(stdout); char *tempdir = g_strdup_printf("%s/plgtest.XXXXXX", g_get_tmp_dir()); if (!mkdtemp(tempdir)) { g_free(tempdir); osync_trace(TRACE_INTERNAL, "unable to create temporary dir: %s", g_strerror(errno)); abort(); } char *command = g_strdup_printf("mv %s/* %s &> /dev/null", localdir, tempdir); ret = system(command); if (ret) { g_free(tempdir); g_free(command); osync_trace(TRACE_INTERNAL, "Unable to move files to temporary dir: %d", ret); abort(); } g_free(command); printf("."); fflush(stdout); check_empty(); printf("."); fflush(stdout); osync_group_set_slow_sync(engine->group, "data", TRUE); sync_now(engine); printf("."); fflush(stdout); command = g_strdup_printf("test \"x$(diff -x \".*\" %s %s)\" = \"x\"", localdir, tempdir); int result = system(command); g_free(command); g_free(tempdir); if (result) abort(); printf(" success\n"); return thistime; }
/* this function is run by the second thread */ void consumer() { int i, time; while (1){ if (i >= 32 ) { i = 0; } time = 0; if (!check_mutex()){ //printf("Mutex Aquired by Consumer\n"); if (!check_empty(i)) { printf("Consumer Printing from Index %d: %d\n", i, product[i].print); printf("Consumer Waiting at Index %d: %d\n", i, product[i].wait_time); time = product[i].wait_time; product[i].print = -1; product[i].wait_time = -1; } pthread_mutex_unlock(&lock); //printf("Mutex released by Consumer\n"); sleep(time); } //else { // printf("Consumer did not obtain Mutex.\n"); //} i++; } }
int unionfs_rmdir(struct inode *dir, struct dentry *dentry) { int err = 0; struct unionfs_dir_state *namelist = NULL; print_entry_location(); lock_dentry(dentry); fist_print_dentry("IN unionfs_rmdir: ", dentry); /* check if this unionfs directory is empty or not */ err = check_empty(dentry, &namelist); if (err) { goto out; } if (IS_SET(dir->i_sb, DELETE_WHITEOUT)) { /* Delete the first directory. */ err = unionfs_rmdir_first(dir, dentry, namelist); /* create whiteout */ if (!err) { err = create_whiteout(dentry, dbstart(dentry)); } else { int new_err; if (dbstart(dentry) == 0) goto out; /* exit if the error returned was NOT -EROFS */ if (!IS_COPYUP_ERR(err)) goto out; new_err = create_whiteout(dentry, dbstart(dentry) - 1); if (new_err != -EEXIST) err = new_err; } } else { /* delete all. */ err = unionfs_rmdir_all(dir, dentry, namelist); } out: /* call d_drop so the system "forgets" about us */ if (!err) d_drop(dentry); if (namelist) free_rdstate(namelist); unlock_dentry(dentry); print_exit_status(err); return err; }
/* We can't copyup a directory, because it may involve huge * numbers of children, etc. Doing that in the kernel would * be bad, so instead we let the userspace recurse and ask us * to copy up each file separately */ static int may_rename_dir(struct dentry *dentry) { int err, bstart; err = check_empty(dentry, NULL); if (err == -ENOTEMPTY) { if (is_robranch(dentry)) return -EXDEV; } else if (err) return err; bstart = dbstart(dentry); if (dbend(dentry) == bstart || dbopaque(dentry) == bstart) return 0; set_dbstart(dentry, bstart + 1); err = check_empty(dentry, NULL); set_dbstart(dentry, bstart); if (err == -ENOTEMPTY) err = -EXDEV; return err; }
char *get_line_not_empty(int fd, int *line) { char *str; if ((str = get_next_line(fd)) == NULL || (str = epur_str(str)) == NULL) return (NULL); (*line)++; while (str != NULL && check_empty(str) == 0) { if ((str = get_next_line(fd)) == NULL || (str = epur_str(str)) == NULL) return (NULL); (*line)++; } return (str); }
int unionfs_rmdir(struct inode *dir, struct dentry *dentry) { int err = 0; struct unionfs_dir_state *namelist = NULL; unionfs_lock_dentry(dentry); /* check if this unionfs directory is empty or not */ err = check_empty(dentry, &namelist); if (err) goto out; err = unionfs_rmdir_first(dir, dentry, namelist); /* create whiteout */ if (!err) err = create_whiteout(dentry, dbstart(dentry)); else { int new_err; if (dbstart(dentry) == 0) goto out; /* exit if the error returned was NOT -EROFS */ if (!IS_COPYUP_ERR(err)) goto out; new_err = create_whiteout(dentry, dbstart(dentry) - 1); if (new_err != -EEXIST) err = new_err; } out: /* call d_drop so the system "forgets" about us */ if (!err) d_drop(dentry); if (namelist) free_rdstate(namelist); unionfs_unlock_dentry(dentry); return err; }
int check_action(char *str, t_action *action, t_pos *pos, t_ftab *ftab) { char **tab; t_action *new_action; int ret; if (!check_empty(str)) return (0); if (!(new_action = create_action_list()) || !(str = format_instruction(str)) || !(tab = cut_instruction(str)) || (ret = check_name(tab[0], new_action, pos)) == -1) return (1); if (ftab[ret] != NULL) { new_action->pos = 0; if (ftab[ret](new_action, tab[1], pos)) return (1); } add_action(action, new_action); return (0); }
static void empty_all(OSyncEngine *engine) { printf("."); fflush(stdout); osync_group_set_slow_sync(engine->group, "data", TRUE); sync_now(engine); char *command = g_strdup_printf("rm -f %s/*", localdir); int ret = system(command); if (ret) { osync_trace(TRACE_INTERNAL, "Unable to delete data: %d", ret); abort(); } g_free(command); sync_now(engine); printf("."); fflush(stdout); check_empty(); }
int unionfs_rmdir(struct inode *dir, struct dentry *dentry) { int err = 0; struct unionfs_dir_state *namelist = NULL; print_entry_location(); lock_dentry(dentry); fist_print_dentry("IN unionfs_rmdir: ", dentry); /* check if this unionfs directory is empty or not */ err = check_empty(dentry, &namelist); if (err) { #if 0 /* vfs_rmdir(our caller) unhashed the dentry. This will recover * the Unionfs inode number for the directory itself, but the * children are already lost. It seems that tmpfs manages its * way around this by upping the refcount on everything. * * Even if we do this, we still lose the inode numbers of the * children. The best way to fix this is to fix the VFS (or * use persistent inode maps). */ if (d_unhashed(dentry)) d_rehash(dentry); #endif goto out; } #ifdef UNIONFS_DELETE_ALL if (IS_SET(dir->i_sb, DELETE_ALL)) { /* delete all. */ err = unionfs_rmdir_all(dir, dentry, namelist); } else { /* Delete the first directory. */ #endif err = unionfs_rmdir_first(dir, dentry, namelist); /* create whiteout */ if (!err) { err = create_whiteout(dentry, dbstart(dentry)); } else { int new_err; if (dbstart(dentry) == 0) goto out; /* exit if the error returned was NOT -EROFS */ if (!IS_COPYUP_ERR(err)) goto out; new_err = create_whiteout(dentry, dbstart(dentry) - 1); if (new_err != -EEXIST) err = new_err; } #ifdef UNIONFS_DELETE_ALL } #endif out: /* call d_drop so the system "forgets" about us */ if (!err) d_drop(dentry); if (namelist) free_rdstate(namelist); unlock_dentry(dentry); print_exit_status(err); return err; }
void test_deque(int lots) { deque_t d; // test: space for zeros. deque_init(4, &d, 0); check_empty(4, &d); deque_destroy(&d); // test: space for zeros. deque_init(4, &d, 10); pop_back_check_constant(4, &d, 10, 0); check_empty(4, &d); deque_destroy(&d); // test: space for zeros. deque_init(4, &d, 10); pop_front_check_constant(4, &d, 10, 0); check_empty(4, &d); deque_destroy(&d); // test: push back lots, destroy deque_init(4, &d, 0); push_back_counting(4, &d, lots); iterate_counting(4, &d, lots); deque_destroy(&d); // test: push back lots, pop front lots. deque_init(4, &d, 0); push_back_counting(4, &d, lots); iterate_counting(4, &d, lots); pop_front_check_counting(4, &d, lots); check_empty(4, &d); deque_destroy(&d); // test: push back lots, pop back lots. deque_init(4, &d, 0); push_back_counting(4, &d, lots); pop_back_check_counting_reverse(4, &d, lots); check_empty(4, &d); deque_destroy(&d); // test: push front lots, pop front lots. deque_init(4, &d, 0); push_front_counting(4, &d, lots); iterate_counting_reverse(4, &d, lots); //print_deque(4, &d); pop_front_check_counting_reverse(4, &d, lots); //print_deque(4, &d); check_empty(4, &d); deque_destroy(&d); // test: push front lots, pop back lots. deque_init(4, &d, 0); push_front_counting(4, &d, lots); //print_deque(4, &d); pop_back_check_counting(4, &d, lots); //print_deque(4, &d); check_empty(4, &d); deque_destroy(&d); // test: push both lots, pop back lots, pop back lots. deque_init(4, &d, 0); push_both_counting(4, &d, lots); //print_deque(4, &d); pop_back_check_counting_reverse(4, &d, lots); pop_back_check_counting(4, &d, lots); check_empty(4, &d); deque_destroy(&d); // test: push both lots, pop front lots, pop front lots. deque_init(4, &d, 0); push_both_counting(4, &d, lots); //print_deque(4, &d); pop_front_check_counting_reverse(4, &d, lots); pop_front_check_counting(4, &d, lots); check_empty(4, &d); deque_destroy(&d); // test: push both lots, pop back lots, pop front lots deque_init(4, &d, 0); push_both_counting(4, &d, lots); //print_deque(4, &d); pop_back_check_counting_reverse(4, &d, lots); pop_front_check_counting_reverse(4, &d, lots); check_empty(4, &d); deque_destroy(&d); // test: push both lots, pop front lots, pop back lots deque_init(4, &d, 0); push_both_counting(4, &d, lots); //print_deque(4, &d); pop_front_check_counting_reverse(4, &d, lots); pop_back_check_counting_reverse(4, &d, lots); check_empty(4, &d); deque_destroy(&d); }
int unionfs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { int err = 0; struct dentry *wh_dentry; double_lock_dentry(old_dentry, new_dentry); if (!S_ISDIR(old_dentry->d_inode->i_mode)) err = unionfs_partial_lookup(old_dentry); else err = may_rename_dir(old_dentry); if (err) goto out; err = unionfs_partial_lookup(new_dentry); if (err) goto out; /* * if new_dentry is already hidden because of whiteout, * simply override it even if the whiteouted dir is not empty. */ wh_dentry = lookup_whiteout(new_dentry); if (!IS_ERR(wh_dentry)) dput(wh_dentry); else if (new_dentry->d_inode) { if (S_ISDIR(old_dentry->d_inode->i_mode) != S_ISDIR(new_dentry->d_inode->i_mode)) { err = S_ISDIR(old_dentry->d_inode->i_mode) ? -ENOTDIR : -EISDIR; goto out; } if (S_ISDIR(new_dentry->d_inode->i_mode)) { struct unionfs_dir_state *namelist; /* check if this unionfs directory is empty or not */ err = check_empty(new_dentry, &namelist); if (err) goto out; if (!is_robranch(new_dentry)) err = delete_whiteouts(new_dentry, dbstart(new_dentry), namelist); free_rdstate(namelist); if (err) goto out; } } err = do_unionfs_rename(old_dir, old_dentry, new_dir, new_dentry); out: if (err) /* clear the new_dentry stuff created */ d_drop(new_dentry); else /* force re-lookup since the dir on ro branch is not renamed, and hidden dentries still indicate the un-renamed ones. */ if (S_ISDIR(old_dentry->d_inode->i_mode)) atomic_dec(&UNIONFS_D(old_dentry)->generation); unionfs_unlock_dentry(new_dentry); unionfs_unlock_dentry(old_dentry); return err; }
int unionfs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { int err = 0; struct dentry *wh_dentry; print_entry_location(); double_lock_dentry(old_dentry, new_dentry); fist_checkinode(old_dir, "unionfs_rename-old_dir"); fist_checkinode(new_dir, "unionfs_rename-new_dir"); fist_print_dentry("IN: unionfs_rename, old_dentry", old_dentry); fist_print_dentry("IN: unionfs_rename, new_dentry", new_dentry); if (!S_ISDIR(old_dentry->d_inode->i_mode)) err = unionfs_partial_lookup(old_dentry); else err = may_rename_dir(old_dentry); if (err) goto out; err = unionfs_partial_lookup(new_dentry); if (err) goto out; /* * if new_dentry is already hidden because of whiteout, * simply override it even if the whiteouted dir is not empty. */ wh_dentry = lookup_whiteout(new_dentry); if (!IS_ERR(wh_dentry)) DPUT(wh_dentry); else if (new_dentry->d_inode) { if (S_ISDIR(old_dentry->d_inode->i_mode) != S_ISDIR(new_dentry->d_inode->i_mode)) { err = S_ISDIR(old_dentry->d_inode-> i_mode) ? -ENOTDIR : -EISDIR; goto out; } if (S_ISDIR(old_dentry->d_inode->i_mode)) { /* check if this unionfs directory is empty or not */ err = check_empty(new_dentry, NULL); if (err) goto out; /* Handle the case where we are overwriting directories * that are not really empty because of whiteout or * non-whiteout entries. */ } } #ifdef UNIONFS_DELETE_ALL if (IS_SET(old_dir->i_sb, DELETE_ALL)) err = unionfs_rename_all(old_dir, old_dentry, new_dir, new_dentry); else #endif err = unionfs_rename_whiteout(old_dir, old_dentry, new_dir, new_dentry); out: fist_checkinode(new_dir, "post unionfs_rename-new_dir"); fist_print_dentry("OUT: unionfs_rename, old_dentry", old_dentry); if (err) { /* clear the new_dentry stuff created */ d_drop(new_dentry); } else { /* force re-lookup since the dir on ro branch is not renamed, and hidden dentries still indicate the un-renamed ones. */ if (S_ISDIR(old_dentry->d_inode->i_mode)) atomic_dec(&dtopd(old_dentry)->udi_generation); fist_print_dentry("OUT: unionfs_rename, new_dentry", new_dentry); } unlock_dentry(new_dentry); unlock_dentry(old_dentry); print_exit_status(err); return err; }
int minimax(struct Node *current,char turn,char matrix[3][3][3][3],char main_matrix[3][3],char x,char y,char w, char z,char maxd) { count ++; printf("%d\n",count); char mind,maxi,maxival; if(maxd>=0) { mind=maxd; int p,i,j,f,l,*empty,k,move; char a,b,c,d; empty = NULL; char copy[3][3][3][3]; for(i=0;i<81;i++) current->child[i]=NULL; if (check_winner(matrix[w][z])=='x') { main_matrix[w][z]='x'; printf("one"); if(check_win_main(main_matrix)=='x') { printf("two"); current->val=1; current->depth=0; return 1; } else if(check_win_main(main_matrix)=='t') { current->val=0; current->depth=0; return 0; } } else if (check_winner(matrix[w][z])=='o') { main_matrix[w][z]='o'; // printmatrix2d(main_matrix); if(check_win_main(main_matrix)=='o') { current->val=-1; current->depth=0; return -1; } else if(check_win_main(main_matrix)=='t') { current->val=0; current->depth=0; return 0; } } empty=check_empty(matrix,main_matrix,x,y); // printf("empty 0 = %d\n",empty[0]); for(i=0;empty[i]!=-1&&i<81;i++) { // printf("Inside Loop---%d\n",i); a=empty[i]/1000; b=empty[i]/100 - a*10; c=empty[i]/10 - a*100 - b*10; d=empty[i]-a*1000 - b*100 - c*10; for(p=0;p<3;p++) { for(j=0;j<3;j++) { for(f=0;f<3;f++) { for(l=0;l<3;l++) { copy[p][j][f][l]=matrix[p][j][f][l]; } } } } current->child[i]=(struct Node *) malloc(sizeof(struct Node)); // if(turn == 'x') // { // copy[a][b][c][d]='x'; // minimax(current->child[i],'o',copy,main_matrix,c,d,a,b); // } // else // { // copy[a][b][c][d]='o'; // minimax(current->child[i],'x',copy,main_matrix,c,d,a,b); // } // if(i!=0) { if(turn=='x') { copy[a][b][c][d]=='x'; if(maxival==1) { k=minimax(current->child[i],'o',copy,main_matrix,c,d,a,b,mind-1); if(k==1) { current->depth=(current->child[i])->depth+1; mind=current->depth; maxi=i; } } else { k=minimax(current->child[i],'o',copy,main_matrix,c,d,a,b,82); if(k==maxival) { if (((current->child[i])->depth + 1)>maxd) { current->depth=((current->child[i])->depth + 1); maxi=i; maxd=current->depth; } } else { if(k>maxival) { current->depth=((current->child[i])->depth + 1); maxd=current->depth; maxi=i; maxival=k; } } } } else { copy[a][b][c][d]=='o'; if(maxival==-1) { k=minimax(current->child[i],'x',copy,main_matrix,c,d,a,b,mind-1); if(k==1) { current->depth=(current->child[i])->depth+1; mind=current->depth; maxi=i; } } else { k=minimax(current->child[i],'x',copy,main_matrix,c,d,a,b,82); if(k==maxival) { if (((current->child[i])->depth + 1)>maxd) { current->depth=((current->child[i])->depth + 1); maxi=i; maxd=current->depth; } } else { if(k<maxival&&k!=-2) { current->depth=((current->child[i])->depth + 1); maxd=current->depth; maxi=i; maxival=k; } } } } } else { if(turn=='x') { copy[a][b][c][d]='x'; maxival=minimax(current->child[i],'x',copy,main_matrix,c,d,a,b,82); maxi=i; current->depth=((current->child[i])->depth + 1); if(maxival=1) mind=current->depth; } else { copy[a][b][c][d]='o'; maxival=minimax(current->child[i],'o',copy,main_matrix,c,d,a,b,82); maxi=i; current->depth=((current->child[i])->depth + 1); if(maxival==-1) mind=current->depth; } } } // if(turn=='x') // k=maxmove(current); // else // k=minmove(current); // current->depth=(current->child[k])->depth + 1; move=empty[maxi]; free(empty); empty=NULL; return maxival; } else return -2; }
/** * Parse a directory tree from the given XML source into the given index data structure. * @param reader the XML source * @param parent Directory where the new subdirectory should be created, or NULL to populate the * root dentry. * @param idx LTFS index data * @param vol LTFS volume to which the index belongs. May be NULL. * @return 0 on success or a negative value on error */ int _xml_parse_dirtree(xmlTextReaderPtr reader, struct dentry *parent, struct ltfs_index *idx, struct ltfs_volume *vol, struct name_list *dirname) { int ret; unsigned long long value_int; struct dentry *dir; declare_parser_vars("directory"); declare_tracking_arrays(9, 1); if (! parent && idx->root) { dir = idx->root; dir->vol = vol; } else { dir = fs_allocate_dentry(parent, NULL, NULL, true, false, false, idx); if (! dir) { ltfsmsg(LTFS_ERR, "10001E", __FUNCTION__); return -LTFS_NO_MEMORY; } if (! parent) { idx->root = dir; dir->vol = vol; ++dir->link_count; } } while (true) { get_next_tag(); if (!strcmp(name, "name")) { check_required_tag(0); if (parent) { get_tag_text(); if (xml_parse_filename(&dir->name, value) < 0) return -1; dirname->name = dir->name; dirname->d = dir; check_tag_end("name"); } else { /* this is the root directory, so set the volume name */ check_empty(); if (empty > 0) { value = NULL; } else { if (xml_scan_text(reader, &value) < 0) return -1; } if (value && strlen(value) > 0) { if (xml_parse_filename(&idx->volume_name, value) < 0) return -1; /* if the value is the empty string, then xml_scan_text consumed the "name" * element end */ check_tag_end("name"); } else idx->volume_name = NULL; } } else if (!strcmp(name, "readonly")) { check_required_tag(1); get_tag_text(); if (xml_parse_bool(&dir->readonly, value) < 0) return -1; check_tag_end("readonly"); } else if (!strcmp(name, "modifytime")) { check_required_tag(2); get_tag_text(); ret = xml_parse_time(true, value, &dir->modify_time); if (ret < 0) return -1; else if (ret == LTFS_TIME_OUT_OF_RANGE) ltfsmsg(LTFS_WARN, "17220W", "updatetime", dir->name, dir->uid, value); check_tag_end("modifytime"); } else if (!strcmp(name, "creationtime")) { check_required_tag(3); get_tag_text(); ret = xml_parse_time(true, value, &dir->creation_time); if (ret < 0) return -1; else if (ret == LTFS_TIME_OUT_OF_RANGE) ltfsmsg(LTFS_WARN, "17220W", "creationtime", dir->name, dir->uid, value); check_tag_end("creationtime"); } else if (!strcmp(name, "accesstime")) { check_required_tag(4); get_tag_text(); ret = xml_parse_time(true, value, &dir->access_time); if (ret < 0) return -1; else if (ret == LTFS_TIME_OUT_OF_RANGE) ltfsmsg(LTFS_WARN, "17220W", "accesstime", dir->name, dir->uid, value); check_tag_end("accesstime"); } else if (!strcmp(name, "changetime")) { check_required_tag(5); get_tag_text(); ret = xml_parse_time(true, value, &dir->change_time); if (ret < 0) return -1; else if (ret == LTFS_TIME_OUT_OF_RANGE) ltfsmsg(LTFS_WARN, "17220W", "changetime", dir->name, dir->uid, value); check_tag_end("changetime"); } else if (! strcmp(name, "contents")) { check_required_tag(6); check_empty(); if (empty == 0 && (ret = _xml_parse_dir_contents(reader, dir, idx)) < 0) { if (ret == -LTFS_NO_MEMORY) return ret; else return -1; } } else if (!strcmp(name, "extendedattributes")) { check_optional_tag(0); check_empty(); if (empty == 0 && _xml_parse_xattrs(reader, dir) < 0) return -1; } else if (idx->version >= IDX_VERSION_UID && ! strcmp(name, UID_TAGNAME)) { check_required_tag(7); get_tag_text(); if (xml_parse_ull(&value_int, value) < 0) return -1; dir->uid = value_int; if (dir->uid > idx->uid_number) idx->uid_number = dir->uid; if (parent) { dirname->uid = dir->uid; } check_tag_end(UID_TAGNAME); } else if (! strcmp(name, UID_TAGNAME)) { ignore_unrecognized_tag(); } else if (idx->version >= IDX_VERSION_BACKUPTIME && ! strcmp(name, BACKUPTIME_TAGNAME)) { check_required_tag(8); get_tag_text(); ret = xml_parse_time(true, value, &dir->backup_time); if (ret < 0) return -1; else if (ret == LTFS_TIME_OUT_OF_RANGE) ltfsmsg(LTFS_WARN, "17220W", "backuptime", dir->name, dir->uid, value); check_tag_end(BACKUPTIME_TAGNAME); } else if (! strcmp(name, BACKUPTIME_TAGNAME)) { ignore_unrecognized_tag(); } else preserve_unrecognized_tag(dir); } /* For old index versions, allocate a UID */ if (idx->version < IDX_VERSION_UID) { check_required_tag(7); if (parent) { dir->uid = fs_allocate_uid(idx); if (dir->uid > idx->uid_number) idx->uid_number = dir->uid; dirname->uid = dir->uid; } /* root directory already got assigned UID 1 by fs_allocate_dentry */ } /* For old index versions, set backup time equal to creation time */ if (idx->version < IDX_VERSION_BACKUPTIME) { check_required_tag(8); dir->backup_time = dir->creation_time; } check_required_tags(); /* Validate UID: root directory must have uid==1, other dentries must have nonzero UID */ /* TODO: would be nice to verify that there are no UID conflicts */ if (parent && dir->uid == 1) { ltfsmsg(LTFS_ERR, "17101E"); return -1; } else if (! parent && dir->uid != 1) { ltfsmsg(LTFS_ERR, "17100E"); return -1; } else if (dir->uid == 0) { ltfsmsg(LTFS_ERR, "17106E"); return -1; } return 0; }
int basic_insertion_test() { long result = errors_counter(); typedef containers::ternary_tree<std::basic_string<CharT>, int> Tst; Tst tst; const char* strings[] = { "\0", "aa", "aab", "aac", "add", "aee", "bab" }; widen<CharT> w; // Construction postconditions check_empty(tst); // Standard insert() tst.insert(std::make_pair(w(strings[1]), 1)); tst.insert(std::make_pair(w(strings[5]), 5)); std::pair<std::basic_string<CharT>, int> inval(w(strings[3]), 3); std::pair<Tst::iterator, bool> vr = tst.insert(inval); BOOST_CHECK(vr.first != tst.end()); BOOST_CHECK(vr.second == true); vr = tst.insert(inval); BOOST_CHECK(vr.first != tst.end()); BOOST_CHECK(vr.second == false); BOOST_CHECK((*tst.find(w(strings[1]))) == 1); BOOST_CHECK((*tst.find(w(strings[3]))) == 3); BOOST_CHECK((*tst.find(w(strings[5]))) == 5); BOOST_CHECK(tst.item_count() == 3); BOOST_CHECK(tst.total_key_length() == 3*3-1); // In present version, no reassignment tst.insert(std::make_pair(w(strings[1]), 4)); BOOST_CHECK((*tst.find(w(strings[1]))) == 1); BOOST_CHECK(tst.item_count() == 3); BOOST_CHECK(tst.total_key_length() == 3*3-1); // reference_proxy insert() tst[w(strings[2])] = 2; tst[w(strings[6])] = 6; tst[w(strings[4])] = 4; BOOST_CHECK(tst[w(strings[2])] == 2); BOOST_CHECK(tst[w(strings[4])] == 4); BOOST_CHECK(tst[w(strings[6])] == 6); BOOST_CHECK(tst.item_count() == 6); BOOST_CHECK(tst.total_key_length() == 6*3-1); // Now do reassignment tst[w(strings[1])] = 7; BOOST_CHECK((*tst.find(w(strings[1]))) == 7); //1); tst[w(strings[1])] = 1; // iterator used to check sort order of strings Tst::const_iterator it(tst.begin()); int expect_val = 1; while (it != tst.end()) { Tst::value_type val = *it; // string == "a", "b" etc BOOST_CHECK(expect_val == 1 || it.key().size() == 3); BOOST_CHECK(it.key() == w(strings[expect_val])); // value is 1, 2 etc BOOST_CHECK(val == expect_val++); ++it; } BOOST_CHECK(expect_val == int(tst.item_count() + 1)); // Test clear() postconditions tst.clear(); check_empty(tst); return errors_counter() - result; }
void test(const Cont &) { // Testing if all types are provided. typename Cont::value_type t0; typename Cont::reference t1 = t0; CGAL_USE(t1); typename Cont::const_reference t2 = t0; CGAL_USE(t2); typename Cont::pointer t3 = &t0; typename Cont::const_pointer t4 = &t0; CGAL_USE(t4); typename Cont::size_type t5 = 0; CGAL_USE(t5); typename Cont::difference_type t6 = t3-t3; CGAL_USE(t6); typename Cont::iterator t7; CGAL_USE(t7); typename Cont::const_iterator t8; CGAL_USE(t8); typename Cont::reverse_iterator t9; CGAL_USE(t9); typename Cont::const_reverse_iterator t10; CGAL_USE(t10); typename Cont::allocator_type t15; std::cout << "Testing empty containers." << std::endl; Cont c0, c1; Cont c2(t15); Cont c3(c2); Cont c4; c4 = c2; typedef std::vector<typename Cont::value_type> Vect; Vect v0; const Cont c5(v0.begin(), v0.end()); Cont c6(c5.begin(), c5.end()); typename Cont::allocator_type Al; Cont c7(c0.begin(), c0.end(), Al); Cont c8; c8.insert(c0.rbegin(), c0.rend()); // test conversion iterator-> const_iterator. typename Cont::const_iterator t16 = c5.begin(); CGAL_USE(t16); assert(t16 == c5.begin()); assert(c0 == c1); assert(! (c0 < c1)); assert(check_empty(c0)); assert(check_empty(c1)); assert(check_empty(c2)); assert(check_empty(c3)); assert(check_empty(c4)); assert(check_empty(c5)); assert(check_empty(c6)); assert(check_empty(c7)); assert(check_empty(c8)); c1.swap(c0); assert(check_empty(c0)); assert(check_empty(c1)); c1.merge(c0); assert(check_empty(c0)); assert(check_empty(c1)); typename Cont::allocator_type t20 = c0.get_allocator(); std::cout << "Now filling some containers" << std::endl; Vect v1(10000); Cont c9(v1.begin(), v1.end()); assert(c9.size() == v1.size()); assert(c9.max_size() >= v1.size()); assert(c9.capacity() >= c9.size()); Cont c10 = c9; assert(c10 == c9); assert(c10.size() == v1.size()); assert(c10.max_size() >= v1.size()); assert(c10.capacity() >= c10.size()); c9.clear(); assert(check_empty(c9)); assert(c9.capacity() >= c9.size()); assert(c0 == c9); c9.merge(c10); c10.swap(c9); assert(check_empty(c9)); assert(c9.capacity() >= c9.size()); assert(c10.size() == v1.size()); assert(c10.max_size() >= v1.size()); assert(c10.capacity() >= c10.size()); std::cout << "Testing insertion methods" << std::endl; c9.assign(c10.begin(), c10.end()); assert(c9 == c10); c10.assign(c9.begin(), c9.end()); assert(c9 == c10); c9.insert(c10.begin(), c10.end()); assert(c9.size() == 2*v1.size()); c9.clear(); assert(c9 != c10); c9.insert(c10.begin(), c10.end()); assert(c9.size() == v1.size()); assert(c9 == c10); typename Cont::iterator it = c9.iterator_to(*c9.begin()); assert(it == c9.begin()); typename Cont::const_iterator cit = c9.iterator_to(const_cast<typename Cont::const_reference>(*c9.begin())); assert(cit == c9.begin()); typename Cont::iterator s_it = Cont::s_iterator_to(*c9.begin()); assert(s_it == c9.begin()); typename Cont::const_iterator s_cit = Cont::s_iterator_to(const_cast<typename Cont::const_reference>(*c9.begin())); assert(s_cit == c9.begin()); c10 = Cont(); assert(check_empty(c10)); for(typename Vect::const_iterator it = v1.begin(); it != v1.end(); ++it) c10.insert(*it); assert(c10.size() == v1.size()); assert(c9 == c10); c9.erase(c9.begin()); c9.erase(c9.begin()); assert(c9.size() == v1.size() - 2); // test reserve /*Cont c11; c11.reserve(v1.size()); for(typename Vect::const_iterator it = v1.begin(); it != v1.end(); ++it) c11.insert(*it); assert(c11.size() == v1.size()); assert(c10 == c11);*/ // owns() and owns_dereferencable(). for(typename Cont::const_iterator it = c9.begin(), end = c9.end(); it != end; ++it) { assert(c9.owns(it)); assert(c9.owns_dereferencable(it)); assert(! c10.owns(it)); assert(! c10.owns_dereferencable(it)); } assert(c9.owns(c9.end())); assert(! c9.owns_dereferencable(c9.end())); c9.erase(c9.begin(), c9.end()); assert(check_empty(c9)); std::cout << "Testing parallel insertion" << std::endl; { Cont c11; Vect v11(1000000); std::vector<typename Cont::iterator> iterators(v11.size()); tbb::parallel_for( tbb::blocked_range<size_t>( 0, v11.size() ), Insert_in_CCC_functor<Vect, Cont>(v11, c11, iterators) ); assert(c11.size() == v11.size()); std::cout << "Testing parallel erasure" << std::endl; tbb::parallel_for( tbb::blocked_range<size_t>( 0, v11.size() ), Erase_in_CCC_functor<Cont>(c11, iterators) ); assert(c11.empty()); } std::cout << "Testing parallel insertion AND erasure" << std::endl; { Cont c12; Vect v12(1000000); std::vector<tbb::atomic<bool> > free_elements(v12.size()); for(typename std::vector<tbb::atomic<bool> >::iterator it = free_elements.begin(), end = free_elements.end(); it != end; ++it) { *it = true; } tbb::atomic<unsigned int> num_erasures; num_erasures = 0; std::vector<typename Cont::iterator> iterators(v12.size()); tbb::parallel_for( tbb::blocked_range<size_t>( 0, v12.size() ), Insert_and_erase_in_CCC_functor<Vect, Cont>( v12, c12, iterators, free_elements, num_erasures) ); assert(c12.size() == v12.size() - num_erasures); } }
int main() { int i; int producer_wait; for (i = 0; i < 32; ++i){ product[i].print=-1; product[i].wait_time=-1; } //Prints all the data in the array. //for (i = 0; i < 32; ++i){ // printf("Print: %d\n", product[i].print); // printf("Wait: %d\n", product[i].wait_time); //} /* this variable is our reference to the second thread */ pthread_t consumer_thread; /* create a second thread which executes inc_x(&x) */ if(pthread_create(&consumer_thread, NULL, (void *)consumer, (void *)NULL)) { fprintf(stderr, "Error creating thread\n"); return 1; } while (1){ if (i >= 32 ) { i = 0; } producer_wait = 0; if (!check_mutex()){ //printf("Mutex Aquired by Producer\n"); if (check_empty(i)) { product[i].print = rdrand_func(3); product[i].wait_time = rdrand_func(1); printf("Producer Inserting Value %d and Wait Time %d at Index: %d\n", product[i].print, product[i].wait_time, i); producer_wait = rdrand_func(2); printf("Producer is now sleeping for %d seconds\n", producer_wait); } pthread_mutex_unlock(&lock); //printf("Mutex released by Producer\n"); sleep(producer_wait); } //else { // printf("Producer did not obtain Mutex.\n"); //} i++; } /* wait for the second thread to finish */ if(pthread_join(consumer_thread, NULL)) { fprintf(stderr, "Error joining thread\n"); return 2; } return 0; }
/* * The locking rules in unionfs_rename are complex. We could use a simpler * superblock-level name-space lock for renames and copy-ups. */ int unionfs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { int err = 0; struct dentry *wh_dentry; struct dentry *old_parent, *new_parent; int valid = true; unionfs_read_lock(old_dentry->d_sb, UNIONFS_SMUTEX_CHILD); old_parent = dget_parent(old_dentry); new_parent = dget_parent(new_dentry); /* un/lock parent dentries only if they differ from old/new_dentry */ if (old_parent != old_dentry && old_parent != new_dentry) unionfs_lock_dentry(old_parent, UNIONFS_DMUTEX_REVAL_PARENT); if (new_parent != old_dentry && new_parent != new_dentry && new_parent != old_parent) unionfs_lock_dentry(new_parent, UNIONFS_DMUTEX_REVAL_CHILD); unionfs_double_lock_dentry(old_dentry, new_dentry); valid = __unionfs_d_revalidate(old_dentry, old_parent, false); if (!valid) { err = -ESTALE; goto out; } if (!d_deleted(new_dentry) && new_dentry->d_inode) { valid = __unionfs_d_revalidate(new_dentry, new_parent, false); if (!valid) { err = -ESTALE; goto out; } } if (!S_ISDIR(old_dentry->d_inode->i_mode)) err = unionfs_partial_lookup(old_dentry, old_parent); else err = may_rename_dir(old_dentry, old_parent); if (err) goto out; err = unionfs_partial_lookup(new_dentry, new_parent); if (err) goto out; /* * if new_dentry is already lower because of whiteout, * simply override it even if the whited-out dir is not empty. */ wh_dentry = find_first_whiteout(new_dentry); if (!IS_ERR(wh_dentry)) { dput(wh_dentry); } else if (new_dentry->d_inode) { if (S_ISDIR(old_dentry->d_inode->i_mode) != S_ISDIR(new_dentry->d_inode->i_mode)) { err = S_ISDIR(old_dentry->d_inode->i_mode) ? -ENOTDIR : -EISDIR; goto out; } if (S_ISDIR(new_dentry->d_inode->i_mode)) { struct unionfs_dir_state *namelist = NULL; /* check if this unionfs directory is empty or not */ err = check_empty(new_dentry, new_parent, &namelist); if (err) goto out; if (!is_robranch(new_dentry)) err = delete_whiteouts(new_dentry, dbstart(new_dentry), namelist); free_rdstate(namelist); if (err) goto out; } } err = do_unionfs_rename(old_dir, old_dentry, old_parent, new_dir, new_dentry, new_parent); if (err) goto out; /* * force re-lookup since the dir on ro branch is not renamed, and * lower dentries still indicate the un-renamed ones. */ if (S_ISDIR(old_dentry->d_inode->i_mode)) atomic_dec(&UNIONFS_D(old_dentry)->generation); else unionfs_postcopyup_release(old_dentry); if (new_dentry->d_inode && !S_ISDIR(new_dentry->d_inode->i_mode)) { unionfs_postcopyup_release(new_dentry); unionfs_postcopyup_setmnt(new_dentry); if (!unionfs_lower_inode(new_dentry->d_inode)) { /* * If we get here, it means that no copyup was * needed, and that a file by the old name already * existing on the destination branch; that file got * renamed earlier in this function, so all we need * to do here is set the lower inode. */ struct inode *inode; inode = unionfs_lower_inode(old_dentry->d_inode); igrab(inode); unionfs_set_lower_inode_idx(new_dentry->d_inode, dbstart(new_dentry), inode); } } /* if all of this renaming succeeded, update our times */ unionfs_copy_attr_times(old_dentry->d_inode); unionfs_copy_attr_times(new_dentry->d_inode); unionfs_check_inode(old_dir); unionfs_check_inode(new_dir); unionfs_check_dentry(old_dentry); unionfs_check_dentry(new_dentry); out: if (err) /* clear the new_dentry stuff created */ d_drop(new_dentry); unionfs_double_unlock_dentry(old_dentry, new_dentry); if (new_parent != old_dentry && new_parent != new_dentry && new_parent != old_parent) unionfs_unlock_dentry(new_parent); if (old_parent != old_dentry && old_parent != new_dentry) unionfs_unlock_dentry(old_parent); dput(new_parent); dput(old_parent); unionfs_read_unlock(old_dentry->d_sb); return err; }