int main () { Eigen::MatrixXd A(3,2); A << -1, 0, 0, -1, 1, 1; Eigen::VectorXd b(3); b << 0, 0, 1; iris::Polyhedron p(A, b); Eigen::MatrixXd A2(2,2); A2 << 2, 3, 4, 5; Eigen::VectorXd b2(2); b2 << 6, 7; iris::Polyhedron other(A2, b2); p.appendConstraints(other); valuecheck(p.getNumberOfConstraints(), 5); Eigen::MatrixXd A_expected(5,2); A_expected << -1, 0, 0, -1, 1, 1, 2, 3, 4, 5; valuecheckMatrix(p.getA(), A_expected, 1e-12); return 0; }
/* existence tests */ void adatet(const struct etent *etptr) { switch (etptr->et_type) { case EXISTS: structcheck(etptr->et_tname, etptr->et_incl, etptr->et_struct, etptr->et_field, etptr->et_offset, etptr->et_value); break; case ALIAS: aliascheck(etptr->et_tname, etptr->et_incl, etptr->et_struct, etptr->et_field, etptr->et_dname); break; case VALUE: valuecheck(etptr->et_tname, etptr->et_incl, etptr->et_struct, etptr->et_dname); break; case DEFINED: funccheck(etptr->et_tname, etptr->et_incl, etptr->et_struct); break; default: tst_resm(TBROK, "invalid type %d", etptr->et_type); break; } }
/* existence tests */ void icmp6_et(void) { int i; for (i = 0; i < ETCOUNT; ++i) { switch (etab[i].et_type) { case EXISTS: structcheck(etab[i].et_tname, etab[i].et_incl, etab[i].et_struct, etab[i].et_field, etab[i].et_offset, etab[i].et_value); break; case ALIAS: aliascheck(etab[i].et_tname, etab[i].et_incl, etab[i].et_struct, etab[i].et_field, etab[i].et_dname); break; case VALUE: valuecheck(etab[i].et_tname, etab[i].et_incl, etab[i].et_struct, etab[i].et_dname); break; case DEFINED: funccheck(etab[i].et_tname, etab[i].et_incl, etab[i].et_struct); break; default: tst_resm(TBROK, "invalid type %d", etab[i].et_type); break; } } }
static int process_leaf_attr_local( struct xfs_mount *mp, xfs_attr_leafblock_t *leaf, int i, xfs_attr_leaf_entry_t *entry, xfs_dahash_t last_hashval, xfs_dablk_t da_bno, xfs_ino_t ino) { xfs_attr_leaf_name_local_t *local; local = xfs_attr3_leaf_name_local(leaf, i); if (local->namelen == 0 || namecheck((char *)&local->nameval[0], local->namelen)) { do_warn( _("attribute entry %d in attr block %u, inode %" PRIu64 " has bad name (namelen = %d)\n"), i, da_bno, ino, local->namelen); return -1; } /* Check on the hash value. Checking order of values * is not necessary, since one wrong clears the whole * fork. If the ordering's wrong, it's caught here or * the kernel code has a bug with transaction logging * or attributes itself. Being paranoid, let's check * ordering anyway in case both the name value and the * hashvalue were wrong but matched. Unlikely, however. */ if (be32_to_cpu(entry->hashval) != libxfs_da_hashname( &local->nameval[0], local->namelen) || be32_to_cpu(entry->hashval) < last_hashval) { do_warn( _("bad hashvalue for attribute entry %d in attr block %u, inode %" PRIu64 "\n"), i, da_bno, ino); return -1; } /* Only check values for root security attributes */ if (entry->flags & XFS_ATTR_ROOT) { if (valuecheck(mp, (char *)&local->nameval[0], NULL, local->namelen, be16_to_cpu(local->valuelen))) { do_warn( _("bad security value for attribute entry %d in attr block %u, inode %" PRIu64 "\n"), i, da_bno, ino); return -1; } } return xfs_attr_leaf_entsize_local(local->namelen, be16_to_cpu(local->valuelen)); }
int main(int argc, char *argv[]) { int i, lc; char *msg; /* Parse standard options given to run the test. */ msg = parse_opts(argc, argv, (option_t *)NULL, NULL); if (msg != (char *)NULL) { tst_brkm(TBROK, tst_exit, "OPTION PARSING ERROR - %s", msg); } setup(); for (lc = 0; TEST_LOOPING(lc); ++lc) { for (i=0; i<FTCOUNT; ++i) { switch (ftab[i].ft_type) { case EXISTS: structcheck(ftab[i].ft_tname, ftab[i].ft_incl, ftab[i].ft_struct, ftab[i].ft_field, ftab[i].ft_offset, ftab[i].ft_value); break; case ALIAS: aliascheck(ftab[i].ft_tname, ftab[i].ft_incl, ftab[i].ft_struct, ftab[i].ft_field, ftab[i].ft_dname); break; case VALUE: valuecheck(ftab[i].ft_tname, ftab[i].ft_incl, ftab[i].ft_struct, ftab[i].ft_dname); break; default: tst_resm(TBROK, "invalid type %d", ftab[i].ft_type); break; } } } cleanup(); /* NOTREACHED */ return 0; }
void do_test(const struct ftent *ftptr) { switch (ftptr->ft_type) { case EXISTS: structcheck(ftptr->ft_tname, ftptr->ft_incl, ftptr->ft_struct, ftptr->ft_field, ftptr->ft_offset, ftptr->ft_value); break; case ALIAS: aliascheck(ftptr->ft_tname, ftptr->ft_incl, ftptr->ft_struct, ftptr->ft_field, ftptr->ft_dname); break; case VALUE: valuecheck(ftptr->ft_tname, ftptr->ft_incl, ftptr->ft_struct, ftptr->ft_dname); break; default: tst_resm(TBROK, "invalid type %d", ftptr->ft_type); break; } }
static int process_leaf_attr_remote( xfs_attr_leafblock_t *leaf, int i, xfs_attr_leaf_entry_t *entry, xfs_dahash_t last_hashval, xfs_dablk_t da_bno, xfs_ino_t ino, xfs_mount_t *mp, blkmap_t *blkmap) { xfs_attr_leaf_name_remote_t *remotep; char* value; remotep = xfs_attr3_leaf_name_remote(leaf, i); if (remotep->namelen == 0 || namecheck((char *)&remotep->name[0], remotep->namelen) || be32_to_cpu(entry->hashval) != libxfs_da_hashname((unsigned char *)&remotep->name[0], remotep->namelen) || be32_to_cpu(entry->hashval) < last_hashval || be32_to_cpu(remotep->valueblk) == 0) { do_warn( _("inconsistent remote attribute entry %d in attr block %u, ino %" PRIu64 "\n"), i, da_bno, ino); return -1; } if (!(entry->flags & XFS_ATTR_ROOT)) goto out; value = malloc(be32_to_cpu(remotep->valuelen)); if (value == NULL) { do_warn( _("cannot malloc enough for remotevalue attribute for inode %" PRIu64 "\n"), ino); do_warn(_("SKIPPING this remote attribute\n")); goto out; } if (rmtval_get(mp, ino, blkmap, be32_to_cpu(remotep->valueblk), be32_to_cpu(remotep->valuelen), value)) { do_warn( _("remote attribute get failed for entry %d, inode %" PRIu64 "\n"), i, ino); goto bad_free_out; } if (valuecheck(mp, (char *)&remotep->name[0], value, remotep->namelen, be32_to_cpu(remotep->valuelen))) { do_warn( _("remote attribute value check failed for entry %d, inode %" PRIu64 "\n"), i, ino); goto bad_free_out; } free(value); out: return xfs_attr_leaf_entsize_remote(remotep->namelen); bad_free_out: free(value); return -1; }
/* * this routine validates the attributes in shortform format. * a non-zero return repair value means certain attributes are bogus * and were cleared if possible. Warnings do not generate error conditions * if you cannot modify the structures. repair is set to 1, if anything * was fixed. */ static int process_shortform_attr( struct xfs_mount *mp, xfs_ino_t ino, xfs_dinode_t *dip, int *repair) { xfs_attr_shortform_t *asf; xfs_attr_sf_entry_t *currententry, *nextentry, *tempentry; int i, junkit; int currentsize, remainingspace; *repair = 0; asf = (xfs_attr_shortform_t *) XFS_DFORK_APTR(dip); /* Assumption: hdr.totsize is less than a leaf block and was checked * by lclinode for valid sizes. Check the count though. */ if (asf->hdr.count == 0) /* then the total size should just be the header length */ if (be16_to_cpu(asf->hdr.totsize) != sizeof(xfs_attr_sf_hdr_t)) { /* whoops there's a discrepancy. Clear the hdr */ if (!no_modify) { do_warn( _("there are no attributes in the fork for inode %" PRIu64 "\n"), ino); asf->hdr.totsize = cpu_to_be16(sizeof(xfs_attr_sf_hdr_t)); *repair = 1; return(1); } else { do_warn( _("would junk the attribute fork since count is 0 for inode %" PRIu64 "\n"), ino); return(1); } } currentsize = sizeof(xfs_attr_sf_hdr_t); remainingspace = be16_to_cpu(asf->hdr.totsize) - currentsize; nextentry = &asf->list[0]; for (i = 0; i < asf->hdr.count; i++) { currententry = nextentry; junkit = 0; /* don't go off the end if the hdr.count was off */ if ((currentsize + (sizeof(xfs_attr_sf_entry_t) - 1)) > be16_to_cpu(asf->hdr.totsize)) break; /* get out and reset count and totSize */ /* if the namelen is 0, can't get to the rest of the entries */ if (currententry->namelen == 0) { do_warn(_("zero length name entry in attribute fork,")); if (!no_modify) { do_warn( _(" truncating attributes for inode %" PRIu64 " to %d\n"), ino, i); *repair = 1; break; /* and then update hdr fields */ } else { do_warn( _(" would truncate attributes for inode %" PRIu64 " to %d\n"), ino, i); break; } } else { /* It's okay to have a 0 length valuelen, but do a * rough check to make sure we haven't gone outside of * totsize. */ if (remainingspace < currententry->namelen || ((remainingspace - currententry-> namelen) < currententry->valuelen)) { do_warn( _("name or value attribute lengths are too large,\n")); if (!no_modify) { do_warn( _(" truncating attributes for inode %" PRIu64 " to %d\n"), ino, i); *repair = 1; break; /* and then update hdr fields */ } else { do_warn( _(" would truncate attributes for inode %" PRIu64 " to %d\n"), ino, i); break; } } } /* namecheck checks for / and null terminated for file names. * attributes names currently follow the same rules. */ if (namecheck((char *)¤tentry->nameval[0], currententry->namelen)) { do_warn( _("entry contains illegal character in shortform attribute name\n")); junkit = 1; } if (currententry->flags & XFS_ATTR_INCOMPLETE) { do_warn( _("entry has INCOMPLETE flag on in shortform attribute\n")); junkit = 1; } /* Only check values for root security attributes */ if (currententry->flags & XFS_ATTR_ROOT) junkit |= valuecheck(mp, (char *)¤tentry->nameval[0], NULL, currententry->namelen, currententry->valuelen); remainingspace = remainingspace - XFS_ATTR_SF_ENTSIZE(currententry); if (junkit) { if (!no_modify) { /* get rid of only this entry */ do_warn( _("removing attribute entry %d for inode %" PRIu64 "\n"), i, ino); tempentry = (xfs_attr_sf_entry_t *) ((intptr_t) currententry + XFS_ATTR_SF_ENTSIZE(currententry)); memmove(currententry,tempentry,remainingspace); asf->hdr.count -= 1; i--; /* no worries, it will wrap back to 0 */ *repair = 1; continue; /* go back up now */ } else { do_warn( _("would remove attribute entry %d for inode %" PRIu64 "\n"), i, ino); } } /* Let's get ready for the next entry... */ nextentry = (xfs_attr_sf_entry_t *)((intptr_t) nextentry + XFS_ATTR_SF_ENTSIZE(currententry)); currentsize = currentsize + XFS_ATTR_SF_ENTSIZE(currententry); } /* end the loop */ if (asf->hdr.count != i) { if (no_modify) { do_warn( _("would have corrected attribute entry count in inode %" PRIu64 " from %d to %d\n"), ino, asf->hdr.count, i); } else { do_warn( _("corrected attribute entry count in inode %" PRIu64 ", was %d, now %d\n"), ino, asf->hdr.count, i); asf->hdr.count = i; *repair = 1; } } /* ASSUMPTION: currentsize <= totsize */ if (be16_to_cpu(asf->hdr.totsize) != currentsize) { if (no_modify) { do_warn( _("would have corrected attribute totsize in inode %" PRIu64 " from %d to %d\n"), ino, be16_to_cpu(asf->hdr.totsize), currentsize); } else { do_warn( _("corrected attribute entry totsize in inode %" PRIu64 ", was %d, now %d\n"), ino, be16_to_cpu(asf->hdr.totsize), currentsize); asf->hdr.totsize = cpu_to_be16(currentsize); *repair = 1; } } return(*repair); }