Searched refs:roots (Results 1 - 42 of 42) sorted by relevance

/linux-4.1.27/lib/
H A Dbch.c505 * 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 Dreed_solomon.c60 * @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 Ddecode_rs.c48 /* 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 Dqgroup.c1461 * @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 Dbackref.c881 * 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 Dbackref.h56 u64 time_seq, struct ulist **roots);
H A Dtransaction.c1015 * 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 Dbtrfs_inode.h65 * to read in roots of subvolumes
H A Dctree.h66 /* 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 Dctree.c958 * 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 Ddisk-io.c138 * 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 Dioctl.c3058 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 Dsend.c1351 * 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 Dtree-log.c551 * 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 Drelocation.c667 * roots of b-trees that reference the tree block.
2365 * adding their roots to the list while we are merge_reloc_roots()
H A Dextent_io.c3708 * otherwise we commit a super block with btree roots that point to set_btree_ioerr()
H A Dextent-tree.c8629 * 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 Dbch.h43 * @xi_tab: GF(2^m) base for solving degree 2 polynomial roots
H A Drslib.h32 * @nroots: Number of generator roots = number of parity symbols
/linux-4.1.27/crypto/asymmetric_keys/
H A Dpkcs7_trust.c72 /* Self-signed certificates form roots of their own, and if we pkcs7_validate_trust_one()
/linux-4.1.27/fs/btrfs/tests/
H A Dqgroup-tests.c289 * 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 Dxenbus.c307 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 Dram_core.c255 * primitive element to generate roots = 1 persistent_ram_init_ecc()
/linux-4.1.27/include/uapi/linux/
H A Dbtrfs.h257 /* which root are we searching. 0 is the tree of tree roots */
/linux-4.1.27/drivers/pci/
H A Dxen-pcifront.c881 "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 Datmel_nand.c760 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 Ddiskonchip.c122 /* Number of roots */
1668 * primitve element to generate roots = 1 init_nanddoc()
/linux-4.1.27/drivers/acpi/
H A Dpci_root.c591 * TBD: Need PCI interface for enumeration/configuration of roots. acpi_pci_root_add()
/linux-4.1.27/mm/
H A Dksm.c485 * 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 Dsuper.c18 * - 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 DMakefile816 # 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 Ddm-thin-metadata.c197 * Reading the space map roots can fail, so we read it into these
/linux-4.1.27/fs/ext2/
H A Dinode.c947 * b) free the subtrees whose roots are stored in
/linux-4.1.27/kernel/
H A Dcgroup.c161 /* 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 Dxfs_trace.h1476 TP_printk("dev %d:%d agno %u flags %s length %u roots b %u c %u "
/linux-4.1.27/fs/ext4/
H A Dindirect.c867 * b) free the subtrees whose roots are stored in
/linux-4.1.27/drivers/i2c/
H A Di2c-core.c1064 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
/linux-4.1.27/fs/cifs/
H A Dcifspdu.h2102 #define DFSREF_REFERRAL_SERVER 0x00000001 /* all targets are DFS roots */
/linux-4.1.27/block/
H A Dcfq-iosched.c1862 /* no such mapping necessary for !roots */
/linux-4.1.27/fs/ext3/
H A Dinode.c2138 * b) free the subtrees whose roots are stored in
/linux-4.1.27/drivers/net/ethernet/chelsio/cxgb4/
H A Dt4_hw.c2865 * enabled at each module, here we just enable the roots of the interrupt
/linux-4.1.27/fs/ocfs2/
H A Dxattr.c2185 * values that are stored externally. Their tree roots were set up

Completed in 4030 milliseconds