fs/gfs2/dir.c

34  * beginning of the leaf block. The dirents reside in leaves when
41  * used as an array of 64-bit block pointers pointing to the leaf blocks. The
43  * block pointer in the array that points to the same leaf. In fact, when a
45  * point to the same leaf.
47  * When a leaf is completely full, the size of the hash table can be
773  * get_leaf_nr - Get a leaf number associated with the index
775  * @index: hash table index of the targeted leaf
776  * @leaf_out: Resulting leaf block number
819 		struct gfs2_leaf *leaf;
837 			leaf = (struct gfs2_leaf *)bh->b_data;
838 			ln = be64_to_cpu(leaf->lf_next);
870 	struct gfs2_leaf *leaf;
884 	leaf = (struct gfs2_leaf *)bh->b_data;
885 	leaf->lf_depth = cpu_to_be16(depth);
886 	leaf->lf_entries = 0;
887 	leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
888 	leaf->lf_next = 0;
889 	leaf->lf_inode = cpu_to_be64(ip->i_no_addr);
890 	leaf->lf_dist = cpu_to_be32(1);
891 	leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
892 	leaf->lf_sec = cpu_to_be64(tv.tv_sec);
893 	memset(leaf->lf_reserved2, 0, sizeof(leaf->lf_reserved2));
894 	dent = (struct gfs2_dirent *)(leaf+1);
897 	return leaf;
914 	struct gfs2_leaf *leaf;
925 	/*  Turn over a new leaf  */
927 	leaf = new_leaf(inode, &bh, 0);
928 	if (!leaf)
933 	leaf->lf_entries = cpu_to_be16(dip->i_entries);
968 	/*  We're done with the new leaf block, now setup the new
994  * dir_split_leaf - Split a leaf block into two
1019 	/*  Get the old leaf block  */
1039 	/*  Compute the start and len of leaf pointers in the hash table.  */
1317 	   current leaf */
1378 	unsigned leaves = 0, leaf = 0, offset, sort_offset;
1409 	 * zone in case the number of entries in the leaf is corrupt.
1411 	 * leaf block.
1437 						"leaf %llu, entries2 (%u) != "
1446 			sort_id = gfs2_set_cookies(sdp, bh, leaf, &darr[offset],
1452 			larr[leaf++] = bh;
1454 			larr[leaf++] = NULL;
1463 	for(i = 0; i < leaf; i++)
1471  * gfs2_dir_readahead - Issue read-ahead requests for leaf blocks.
1478  * have the leaf, and therefore we don't have the depth, and therefore we
1708  * dir_new_leaf - Add a new leaf onto hash chain
1712  * This adds a new dir leaf onto an existing leaf when there is not
1715  * leaf blocks, so it will only occur for very large directories.
1717  * The dist parameter is set to 1 for leaf blocks directly attached
1719  * etc. We are thus able to tell the difference between an old leaf
1730 	struct gfs2_leaf *leaf, *oleaf;
1754 	leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));
1755 	if (!leaf) {
1759 	leaf->lf_dist = cpu_to_be32(dist);
1805 	struct gfs2_leaf *leaf;
1822 				leaf = (struct gfs2_leaf *)bh->b_data;
1823 				be16_add_cpu(&leaf->lf_entries, 1);
1824 				leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
1825 				leaf->lf_sec = cpu_to_be64(tv.tv_sec);
1904 		struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
1905 		u16 entries = be16_to_cpu(leaf->lf_entries);
1908 		leaf->lf_entries = cpu_to_be16(--entries);
1909 		leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
1910 		leaf->lf_sec = cpu_to_be64(tv.tv_sec);
1964  * leaf_dealloc - Deallocate a directory leaf
1967  * @len: the number of pointers to this leaf
1968  * @leaf_no: the leaf number
1969  * @leaf_bh: buffer_head for the starting leaf
1970  * @last_dealloc: 1 if this is the final dealloc for the leaf, else 0
2094  * gfs2_dir_exhash_dealloc - free all the leaf blocks in a directory
2106 	struct gfs2_leaf *leaf;
2125 			leaf = (struct gfs2_leaf *)bh->b_data;
2126 			len = BIT(dip->i_depth - be16_to_cpu(leaf->lf_depth));