/linux-4.1.27/lib/ |
H A D | bch.c | 505 * this function builds and solves a linear system for finding roots of a degree 510 unsigned int *roots) find_affine4_roots() 539 return solve_linear_system(bch, rows, roots, 4); find_affine4_roots() 546 unsigned int *roots) find_poly_deg1_roots() 552 roots[n++] = mod_s(bch, GF_N(bch)-bch->a_log_tab[poly->c[0]]+ find_poly_deg1_roots() 558 * compute roots of a degree 2 polynomial over GF(2^m) 561 unsigned int *roots) find_poly_deg2_roots() 578 * i.e. r and r+1 are roots iff Tr(u)=0 find_poly_deg2_roots() 590 roots[n++] = modulo(bch, 2*GF_N(bch)-l1- find_poly_deg2_roots() 592 roots[n++] = modulo(bch, 2*GF_N(bch)-l1- find_poly_deg2_roots() 600 * compute roots of a degree 3 polynomial over GF(2^m) 603 unsigned int *roots) find_poly_deg3_roots() 620 /* find the 4 roots of this affine polynomial */ find_poly_deg3_roots() 622 /* remove a2 from final list of roots */ find_poly_deg3_roots() 625 roots[n++] = a_ilog(bch, tmp[i]); find_poly_deg3_roots() 633 * compute roots of a degree 4 polynomial over GF(2^m) 636 unsigned int *roots) find_poly_deg4_roots() 672 /* assume all roots have multiplicity 1 */ find_poly_deg4_roots() 684 /* find the 4 roots of this affine polynomial */ find_poly_deg4_roots() 685 if (find_affine4_roots(bch, a2, b2, c2, roots) == 4) { find_poly_deg4_roots() 687 /* post-process roots (reverse transformations) */ find_poly_deg4_roots() 688 f = a ? gf_inv(bch, roots[i]) : roots[i]; find_poly_deg4_roots() 689 roots[i] = a_ilog(bch, f^e); find_poly_deg4_roots() 871 * find roots of a polynomial, using BTZ algorithm; see the beginning of this 875 struct gf_poly *poly, unsigned int *roots) find_poly_roots() 883 cnt = find_poly_deg1_roots(bch, poly, roots); find_poly_roots() 886 cnt = find_poly_deg2_roots(bch, poly, roots); find_poly_roots() 889 cnt = find_poly_deg3_roots(bch, poly, roots); find_poly_roots() 892 cnt = find_poly_deg4_roots(bch, poly, roots); find_poly_roots() 900 cnt += find_poly_roots(bch, k+1, f1, roots); find_poly_roots() 902 cnt += find_poly_roots(bch, k+1, f2, roots+cnt); find_poly_roots() 915 struct gf_poly *p, unsigned int *roots) chien_search() 934 roots[count++] = GF_N(bch)-i; chien_search() 1169 unsigned int i, j, nbits, r, word, *roots; compute_generator_polynomial() local 1174 roots = bch_alloc((bch->n+1)*sizeof(*roots), &err); compute_generator_polynomial() 1183 /* enumerate all roots of g(X) */ compute_generator_polynomial() 1184 memset(roots , 0, (bch->n+1)*sizeof(*roots)); compute_generator_polynomial() 1187 roots[r] = 1; compute_generator_polynomial() 1195 if (roots[i]) { compute_generator_polynomial() 1223 kfree(roots); compute_generator_polynomial() 508 find_affine4_roots(struct bch_control *bch, unsigned int a, unsigned int b, unsigned int c, unsigned int *roots) find_affine4_roots() argument 545 find_poly_deg1_roots(struct bch_control *bch, struct gf_poly *poly, unsigned int *roots) find_poly_deg1_roots() argument 560 find_poly_deg2_roots(struct bch_control *bch, struct gf_poly *poly, unsigned int *roots) find_poly_deg2_roots() argument 602 find_poly_deg3_roots(struct bch_control *bch, struct gf_poly *poly, unsigned int *roots) find_poly_deg3_roots() argument 635 find_poly_deg4_roots(struct bch_control *bch, struct gf_poly *poly, unsigned int *roots) find_poly_deg4_roots() argument 874 find_poly_roots(struct bch_control *bch, unsigned int k, struct gf_poly *poly, unsigned int *roots) find_poly_roots() argument 914 chien_search(struct bch_control *bch, unsigned int len, struct gf_poly *p, unsigned int *roots) chien_search() argument
|
/linux-4.1.27/lib/reed_solomon/ |
H A D | reed_solomon.c | 60 * @prim: primitive element to generate polynomial roots 61 * @nroots: RS code generator polynomial degree (number of roots) 130 /* Form RS code generator polynomial from its roots */ rs_init() 196 * @prim: primitive element to generate polynomial roots 197 * @nroots: RS code generator polynomial degree (number of roots) 257 * @prim: primitive element to generate polynomial roots 258 * @nroots: RS code generator polynomial degree (number of roots) 276 * @prim: primitive element to generate polynomial roots 277 * @nroots: RS code generator polynomial degree (number of roots)
|
H A D | decode_rs.c | 48 /* form the syndromes; i.e., evaluate data(x) at roots of 178 /* Find roots of error+erasure locator polynomial by Chien search */ 180 count = 0; /* Number of roots of lambda(x) */ 194 /* If we've already found max possible roots, 202 * deg(lambda) unequal to number of roots => uncorrectable
|
/linux-4.1.27/fs/btrfs/ |
H A D | qgroup.c | 1461 * @mod_seq: do we need to get a sequence number for looking up roots. 1559 * Walk all of the roots that pointed to our bytenr and adjust their refcnts as 1564 struct ulist *roots, struct ulist *qgroups, qgroup_calc_old_refcnt() 1575 while ((unode = ulist_next(roots, &uiter))) { qgroup_calc_old_refcnt() 1586 * old roots we find in case we removed ours and added a qgroup_calc_old_refcnt() 1611 * get how many of the roots actually point up to the qgroup_calc_old_refcnt() 1647 * We need to walk forward in our operation tree and account for any roots that 1843 * If our refcount was the same as the roots previously but our qgroup_adjust_counters() 1844 * new count isn't the same as the number of roots now then we qgroup_adjust_counters() 1856 * If we didn't reference all the roots before but now we do we qgroup_adjust_counters() 1874 * then we need to lookup all referenced roots to make sure we still don't 1881 struct ulist *roots = NULL; check_existing_refs() local 1887 oper->elem.seq, &roots); check_existing_refs() 1893 while ((unode = ulist_next(roots, &uiter))) { check_existing_refs() 1899 ulist_free(roots); check_existing_refs() 1906 * If we share a reference across multiple roots then we may need to adjust 1913 * jack this sequence up by the number of roots we found each time in order to 1916 * 2) We first search all the roots that reference the area _except_ the root 1926 * based on the number of roots we had and will have after this operation. 1949 struct ulist *roots = NULL; qgroup_shared_accounting() local 1978 &roots); qgroup_shared_accounting() 1992 * So roots is the list of all the roots currently pointing at the qgroup_shared_accounting() 1999 ret = qgroup_calc_old_refcnt(fs_info, oper->ref_root, tmp, roots, qgroups, qgroup_shared_accounting() 2021 * we have an accurate count of the roots as it pertains to this qgroup_shared_accounting() 2030 * We are adding our root, need to adjust up the number of roots, qgroup_shared_accounting() 2031 * otherwise old_roots is the number of roots we want. qgroup_shared_accounting() 2051 ulist_free(roots); qgroup_shared_accounting() 2065 struct ulist *roots = NULL; qgroup_subtree_accounting() local 2082 elem.seq, &roots); qgroup_subtree_accounting() 2087 if (roots->nnodes != 1) qgroup_subtree_accounting() 2091 unode = ulist_next(roots, &uiter); /* Only want 1 so no need to loop */ qgroup_subtree_accounting() 2156 ulist_free(roots); qgroup_subtree_accounting() 2163 * from the fs. First, all roots referencing the extent are searched, and 2164 * then the space is accounted accordingly to the different roots. The 2415 * difference between the two roots should be the root node. btrfs_qgroup_inherit() 2644 struct ulist *roots = NULL; qgroup_rescan_leaf() local 2700 &roots); qgroup_rescan_leaf() 2705 fs_info->qgroup_seq += roots->nnodes + 1; /* max refcnt */ qgroup_rescan_leaf() 2708 ret = qgroup_calc_old_refcnt(fs_info, 0, tmp, roots, qgroups, qgroup_rescan_leaf() 2712 ulist_free(roots); qgroup_rescan_leaf() 2720 ulist_free(roots); qgroup_rescan_leaf() 2724 ulist_free(roots); qgroup_rescan_leaf() 1562 qgroup_calc_old_refcnt(struct btrfs_fs_info *fs_info, u64 root_to_skip, struct ulist *tmp, struct ulist *roots, struct ulist *qgroups, u64 seq, int *old_roots, int rescan) qgroup_calc_old_refcnt() argument
|
H A D | backref.c | 881 * When roots are found, they're added to the roots list 890 struct ulist *roots, const u64 *extent_item_pos, 1019 if (roots && ref->count && ref->root_id && ref->parent == 0) { 1026 ret = ulist_add(roots, ref->root_id, 0, GFP_NOFS); 1139 * walk all backrefs for a given extent to find all roots that reference this 1147 * list. Found roots are added to the roots list. 1153 u64 time_seq, struct ulist **roots) __btrfs_find_all_roots() 1163 *roots = ulist_alloc(GFP_NOFS); __btrfs_find_all_roots() 1164 if (!*roots) { __btrfs_find_all_roots() 1172 time_seq, tmp, *roots, NULL, 0, 0); __btrfs_find_all_roots() 1175 ulist_free(*roots); __btrfs_find_all_roots() 1191 u64 time_seq, struct ulist **roots) btrfs_find_all_roots() 1197 ret = __btrfs_find_all_roots(trans, fs_info, bytenr, time_seq, roots); btrfs_find_all_roots() 1221 struct ulist *roots = NULL; btrfs_check_shared() local 1228 roots = ulist_alloc(GFP_NOFS); btrfs_check_shared() 1229 if (!tmp || !roots) { btrfs_check_shared() 1231 ulist_free(roots); btrfs_check_shared() 1242 roots, NULL, root_objectid, inum); btrfs_check_shared() 1262 ulist_free(roots); btrfs_check_shared() 1629 struct ulist *roots = NULL; iterate_extent_inodes() local 1657 tree_mod_seq_elem.seq, &roots); iterate_extent_inodes() 1661 while (!ret && (root_node = ulist_next(roots, &root_uiter))) { iterate_extent_inodes() 1671 ulist_free(roots); iterate_extent_inodes() 887 find_parent_nodes(struct btrfs_trans_handle *trans, struct btrfs_fs_info *fs_info, u64 bytenr, u64 time_seq, struct ulist *refs, struct ulist *roots, const u64 *extent_item_pos, u64 root_objectid, u64 inum) find_parent_nodes() argument 1151 __btrfs_find_all_roots(struct btrfs_trans_handle *trans, struct btrfs_fs_info *fs_info, u64 bytenr, u64 time_seq, struct ulist **roots) __btrfs_find_all_roots() argument 1189 btrfs_find_all_roots(struct btrfs_trans_handle *trans, struct btrfs_fs_info *fs_info, u64 bytenr, u64 time_seq, struct ulist **roots) btrfs_find_all_roots() argument
|
H A D | backref.h | 56 u64 time_seq, struct ulist **roots);
|
H A D | transaction.c | 1015 * this is used to update the root pointer in the tree of tree roots. 1054 * update all the cowonly tree roots on disk 1139 * dead roots are old snapshots that need to be deleted. This allocates 1140 * a dirty root struct and adds it into the list of dead roots that need to 1152 * update all the cowonly tree roots on disk 1978 * various roots consistent with each other. Every pointer btrfs_commit_transaction() 1979 * in the tree of tree roots has to point to the most up to date btrfs_commit_transaction() 2005 /* commit_fs_roots gets rid of all the tree log roots, it is now btrfs_commit_transaction() 2006 * safe to free the root of tree log roots btrfs_commit_transaction()
|
H A D | btrfs_inode.h | 65 * to read in roots of subvolumes
|
H A D | ctree.h | 66 /* holds pointers to all of the tree roots */ 80 * one per device. The tree of tree roots points to the device tree 409 * just in case we somehow lose the roots and are not able to mount, 410 * we store an array of the roots from previous transactions 1399 /* the log root tree is a directory of all the other log roots */ 1570 * all fs/file tree roots in which there are data=ordered extents 1580 /* all fs/file tree roots that have delalloc inodes. */ 1888 /* the dirty list is only used by non-reference counted roots */ 2019 * root items point to tree roots. They are typically in the root
|
H A D | ctree.c | 958 * Tree blocks not in refernece counted trees and tree roots btrfs_block_can_be_shared() 1323 * this operation is special. for roots, this must be __tree_mod_log_rewind() 1325 * for non-roots, this operation may exist if the node __tree_mod_log_rewind() 2719 * the commit roots are read only btrfs_search_slot() 5317 * This currently works on commit roots only. As commit roots are read only, 5318 * we don't do any locking. The commit roots are protected with transactions.
|
H A D | disk-io.c | 138 * Different roots are used for different purposes and may nest inside each 141 * by btrfs_root->objectid. This ensures that all special purpose roots 378 * Things reading via commit roots that don't have normal protection, verify_parent_transid() 2110 /* helper to cleanup tree roots */ free_root_pointers() 3665 /* Avoid to grab roots in dead_roots */ btrfs_cleanup_fs_roots() 3687 /* release the uncleaned roots due to error */ btrfs_cleanup_fs_roots()
|
H A D | ioctl.c | 3058 struct ulist *roots; check_ref() local 3068 tree_mod_seq_elem.seq, &roots); check_ref() 3073 while ((root_node = ulist_next(roots, &uiter))) { check_ref() 3079 ulist_free(roots); check_ref() 3542 * We need to look up the roots that point at btrfs_clone()
|
H A D | send.c | 1351 * Setup the clone roots. find_extent_clone() 5654 /* Use any root, all fs roots will get their commit roots updated. */ ensure_commit_roots_uptodate()
|
H A D | tree-log.c | 551 * This can only be called for subvolume roots and not for the log 2520 * in the tree of log roots 2780 * now that we've moved on to the tree of log tree roots, btrfs_sync_log()
|
H A D | relocation.c | 667 * roots of b-trees that reference the tree block. 2365 * adding their roots to the list while we are merge_reloc_roots()
|
H A D | extent_io.c | 3708 * otherwise we commit a super block with btree roots that point to set_btree_ioerr()
|
H A D | extent-tree.c | 8629 * keep trying to do the work later. This also cleans up roots if we btrfs_drop_snapshot()
|
/linux-4.1.27/include/linux/ |
H A D | bch.h | 43 * @xi_tab: GF(2^m) base for solving degree 2 polynomial roots
|
H A D | rslib.h | 32 * @nroots: Number of generator roots = number of parity symbols
|
/linux-4.1.27/crypto/asymmetric_keys/ |
H A D | pkcs7_trust.c | 72 /* Self-signed certificates form roots of their own, and if we pkcs7_validate_trust_one()
|
/linux-4.1.27/fs/btrfs/tests/ |
H A D | qgroup-tests.c | 289 * Add a ref for two different roots to make sure the shared value comes out 290 * right, also remove one of the roots and make sure the exclusive count is
|
/linux-4.1.27/drivers/xen/xen-pciback/ |
H A D | xenbus.c | 307 dev_dbg(&pdev->xdev->dev, "Publishing pci roots\n"); xen_pcibk_publish_pci_root() 437 /* Publish pci roots. */ xen_pcibk_reconfigure() 493 * remove unnecessary xenstore nodes of pci roots here. xen_pcibk_reconfigure()
|
/linux-4.1.27/fs/pstore/ |
H A D | ram_core.c | 255 * primitive element to generate roots = 1 persistent_ram_init_ecc()
|
/linux-4.1.27/include/uapi/linux/ |
H A D | btrfs.h | 257 /* which root are we searching. 0 is the tree of tree roots */
|
/linux-4.1.27/drivers/pci/ |
H A D | xen-pcifront.c | 881 "Error reading number of PCI roots"); pcifront_try_connect() 967 "Error reading number of PCI roots"); pcifront_attach_devices()
|
/linux-4.1.27/drivers/mtd/nand/ |
H A D | atmel_nand.c | 760 int roots_nbr; /* number of roots */ pmecc_err_location() 793 /* Number of roots == degree of smu hence <= cap */ pmecc_err_location() 797 /* Number of roots does not match the degree of smu pmecc_err_location()
|
H A D | diskonchip.c | 122 /* Number of roots */ 1668 * primitve element to generate roots = 1 init_nanddoc()
|
/linux-4.1.27/drivers/acpi/ |
H A D | pci_root.c | 591 * TBD: Need PCI interface for enumeration/configuration of roots. acpi_pci_root_add()
|
/linux-4.1.27/mm/ |
H A D | ksm.c | 485 * This helper is used for getting right index into array of tree roots. 487 * stable and unstable pages from all nodes with roots in index 0. Otherwise, 2208 * a buffer to hold as many roots as may be needed. merge_across_nodes_store()
|
/linux-4.1.27/fs/nfs/ |
H A D | super.c | 18 * - NFS superblocks can have several effective roots to the dentry tree 19 * - directory type roots are spliced into the tree when a path from one root reaches the root
|
/linux-4.1.27/ |
H A D | Makefile | 816 # INSTALL_DTBS_PATH specifies a prefix for relocations required by build roots. 824 # relocations required by build roots. This is not defined in the
|
/linux-4.1.27/drivers/md/ |
H A D | dm-thin-metadata.c | 197 * Reading the space map roots can fail, so we read it into these
|
/linux-4.1.27/fs/ext2/ |
H A D | inode.c | 947 * b) free the subtrees whose roots are stored in
|
/linux-4.1.27/kernel/ |
H A D | cgroup.c | 161 /* The list of hierarchy roots */ 1234 /* can't move between two non-dummy roots either */ for_each_subsys() 1251 * fail. Using both default and non-default roots should
|
/linux-4.1.27/fs/xfs/ |
H A D | xfs_trace.h | 1476 TP_printk("dev %d:%d agno %u flags %s length %u roots b %u c %u "
|
/linux-4.1.27/fs/ext4/ |
H A D | indirect.c | 867 * b) free the subtrees whose roots are stored in
|
/linux-4.1.27/drivers/i2c/ |
H A D | i2c-core.c | 1064 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
|
/linux-4.1.27/fs/cifs/ |
H A D | cifspdu.h | 2102 #define DFSREF_REFERRAL_SERVER 0x00000001 /* all targets are DFS roots */
|
/linux-4.1.27/block/ |
H A D | cfq-iosched.c | 1862 /* no such mapping necessary for !roots */
|
/linux-4.1.27/fs/ext3/ |
H A D | inode.c | 2138 * b) free the subtrees whose roots are stored in
|
/linux-4.1.27/drivers/net/ethernet/chelsio/cxgb4/ |
H A D | t4_hw.c | 2865 * enabled at each module, here we just enable the roots of the interrupt
|
/linux-4.1.27/fs/ocfs2/ |
H A D | xattr.c | 2185 * values that are stored externally. Their tree roots were set up
|