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
770  * get_leaf_nr - Get a leaf number associated with the index
772  * @index: hash table index of the targeted leaf
773  * @leaf_out: Resulting leaf block number
816 		struct gfs2_leaf *leaf;
834 			leaf = (struct gfs2_leaf *)bh->b_data;
835 			ln = be64_to_cpu(leaf->lf_next);
867 	struct gfs2_leaf *leaf;
881 	leaf = (struct gfs2_leaf *)bh->b_data;
882 	leaf->lf_depth = cpu_to_be16(depth);
883 	leaf->lf_entries = 0;
884 	leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
885 	leaf->lf_next = 0;
886 	leaf->lf_inode = cpu_to_be64(ip->i_no_addr);
887 	leaf->lf_dist = cpu_to_be32(1);
888 	leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
889 	leaf->lf_sec = cpu_to_be64(tv.tv_sec);
890 	memset(leaf->lf_reserved2, 0, sizeof(leaf->lf_reserved2));
891 	dent = (struct gfs2_dirent *)(leaf+1);
894 	return leaf;
911 	struct gfs2_leaf *leaf;
922 	/*  Turn over a new leaf  */
924 	leaf = new_leaf(inode, &bh, 0);
925 	if (!leaf)
930 	leaf->lf_entries = cpu_to_be16(dip->i_entries);
965 	/*  We're done with the new leaf block, now setup the new
991  * dir_split_leaf - Split a leaf block into two
1016 	/*  Get the old leaf block  */
1036 	/*  Compute the start and len of leaf pointers in the hash table.  */
1314 	   current leaf */
1375 	unsigned leaves = 0, leaf = 0, offset, sort_offset;
1406 	 * zone in case the number of entries in the leaf is corrupt.
1408 	 * leaf block.
1434 						"leaf %llu, entries2 (%u) != "
1443 			sort_id = gfs2_set_cookies(sdp, bh, leaf, &darr[offset],
1449 			larr[leaf++] = bh;
1451 			larr[leaf++] = NULL;
1460 	for(i = 0; i < leaf; i++)
1468  * gfs2_dir_readahead - Issue read-ahead requests for leaf blocks.
1475  * have the leaf, and therefore we don't have the depth, and therefore we
1705  * dir_new_leaf - Add a new leaf onto hash chain
1709  * This adds a new dir leaf onto an existing leaf when there is not
1712  * leaf blocks, so it will only occur for very large directories.
1714  * The dist parameter is set to 1 for leaf blocks directly attached
1716  * etc. We are thus able to tell the difference between an old leaf
1727 	struct gfs2_leaf *leaf, *oleaf;
1751 	leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));
1752 	if (!leaf) {
1756 	leaf->lf_dist = cpu_to_be32(dist);
1802 	struct gfs2_leaf *leaf;
1819 				leaf = (struct gfs2_leaf *)bh->b_data;
1820 				be16_add_cpu(&leaf->lf_entries, 1);
1821 				leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
1822 				leaf->lf_sec = cpu_to_be64(tv.tv_sec);
1901 		struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
1902 		u16 entries = be16_to_cpu(leaf->lf_entries);
1905 		leaf->lf_entries = cpu_to_be16(--entries);
1906 		leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
1907 		leaf->lf_sec = cpu_to_be64(tv.tv_sec);
1961  * leaf_dealloc - Deallocate a directory leaf
1964  * @len: the number of pointers to this leaf
1965  * @leaf_no: the leaf number
1966  * @leaf_bh: buffer_head for the starting leaf
1967  * @last_dealloc: 1 if this is the final dealloc for the leaf, else 0
2091  * gfs2_dir_exhash_dealloc - free all the leaf blocks in a directory
2103 	struct gfs2_leaf *leaf;
2122 			leaf = (struct gfs2_leaf *)bh->b_data;
2123 			len = BIT(dip->i_depth - be16_to_cpu(leaf->lf_depth));