1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #ifndef __XFS_DIR2_H__ 7 #define __XFS_DIR2_H__ 8 9 #include "xfs_da_format.h" 10 #include "xfs_da_btree.h" 11 12 struct xfs_da_args; 13 struct xfs_inode; 14 struct xfs_mount; 15 struct xfs_trans; 16 struct xfs_dir2_sf_hdr; 17 struct xfs_dir2_sf_entry; 18 struct xfs_dir2_data_hdr; 19 struct xfs_dir2_data_entry; 20 struct xfs_dir2_data_unused; 21 struct xfs_dir3_icfree_hdr; 22 struct xfs_dir3_icleaf_hdr; 23 24 extern const struct xfs_name xfs_name_dotdot; 25 extern const struct xfs_name xfs_name_dot; 26 27 static inline bool 28 xfs_dir2_samename( 29 const struct xfs_name *n1, 30 const struct xfs_name *n2) 31 { 32 if (n1 == n2) 33 return true; 34 if (n1->len != n2->len) 35 return false; 36 return !memcmp(n1->name, n2->name, n1->len); 37 } 38 39 enum xfs_dir2_fmt { 40 XFS_DIR2_FMT_SF, 41 XFS_DIR2_FMT_BLOCK, 42 XFS_DIR2_FMT_LEAF, 43 XFS_DIR2_FMT_NODE, 44 XFS_DIR2_FMT_ERROR, 45 }; 46 47 enum xfs_dir2_fmt xfs_dir2_format(struct xfs_da_args *args, int *error); 48 49 /* 50 * Convert inode mode to directory entry filetype 51 */ 52 extern unsigned char xfs_mode_to_ftype(int mode); 53 54 /* 55 * Generic directory interface routines 56 */ 57 extern void xfs_dir_startup(void); 58 extern int xfs_da_mount(struct xfs_mount *mp); 59 extern void xfs_da_unmount(struct xfs_mount *mp); 60 61 extern int xfs_dir_init(struct xfs_trans *tp, struct xfs_inode *dp, 62 struct xfs_inode *pdp); 63 extern int xfs_dir_createname(struct xfs_trans *tp, struct xfs_inode *dp, 64 const struct xfs_name *name, xfs_ino_t inum, 65 xfs_extlen_t tot); 66 extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp, 67 const struct xfs_name *name, xfs_ino_t *inum, 68 struct xfs_name *ci_name); 69 extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp, 70 const struct xfs_name *name, xfs_ino_t ino, 71 xfs_extlen_t tot); 72 extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp, 73 const struct xfs_name *name, xfs_ino_t inum, 74 xfs_extlen_t tot); 75 extern int xfs_dir_canenter(struct xfs_trans *tp, struct xfs_inode *dp, 76 const struct xfs_name *name); 77 78 int xfs_dir_lookup_args(struct xfs_da_args *args); 79 int xfs_dir_createname_args(struct xfs_da_args *args); 80 int xfs_dir_removename_args(struct xfs_da_args *args); 81 int xfs_dir_replace_args(struct xfs_da_args *args); 82 83 /* 84 * Direct call from the bmap code, bypassing the generic directory layer. 85 */ 86 extern int xfs_dir2_sf_to_block(struct xfs_da_args *args); 87 88 /* 89 * Interface routines used by userspace utilities 90 */ 91 extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db, 92 struct xfs_buf *bp); 93 94 extern void xfs_dir2_data_freescan(struct xfs_mount *mp, 95 struct xfs_dir2_data_hdr *hdr, int *loghead); 96 extern void xfs_dir2_data_log_entry(struct xfs_da_args *args, 97 struct xfs_buf *bp, struct xfs_dir2_data_entry *dep); 98 extern void xfs_dir2_data_log_header(struct xfs_da_args *args, 99 struct xfs_buf *bp); 100 extern void xfs_dir2_data_log_unused(struct xfs_da_args *args, 101 struct xfs_buf *bp, struct xfs_dir2_data_unused *dup); 102 extern void xfs_dir2_data_make_free(struct xfs_da_args *args, 103 struct xfs_buf *bp, xfs_dir2_data_aoff_t offset, 104 xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp); 105 extern int xfs_dir2_data_use_free(struct xfs_da_args *args, 106 struct xfs_buf *bp, struct xfs_dir2_data_unused *dup, 107 xfs_dir2_data_aoff_t offset, xfs_dir2_data_aoff_t len, 108 int *needlogp, int *needscanp); 109 110 extern struct xfs_dir2_data_free *xfs_dir2_data_freefind( 111 struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_data_free *bf, 112 struct xfs_dir2_data_unused *dup); 113 114 extern int xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino); 115 116 xfs_failaddr_t xfs_dir3_leaf_header_check(struct xfs_buf *bp, xfs_ino_t owner); 117 xfs_failaddr_t xfs_dir3_data_header_check(struct xfs_buf *bp, xfs_ino_t owner); 118 xfs_failaddr_t xfs_dir3_block_header_check(struct xfs_buf *bp, xfs_ino_t owner); 119 120 extern const struct xfs_buf_ops xfs_dir3_block_buf_ops; 121 extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops; 122 extern const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops; 123 extern const struct xfs_buf_ops xfs_dir3_free_buf_ops; 124 extern const struct xfs_buf_ops xfs_dir3_data_buf_ops; 125 126 /* 127 * Directory offset/block conversion functions. 128 * 129 * DB blocks here are logical directory block numbers, not filesystem blocks. 130 */ 131 132 /* 133 * Convert dataptr to byte in file space 134 */ 135 static inline xfs_dir2_off_t 136 xfs_dir2_dataptr_to_byte(xfs_dir2_dataptr_t dp) 137 { 138 return (xfs_dir2_off_t)dp << XFS_DIR2_DATA_ALIGN_LOG; 139 } 140 141 /* 142 * Convert byte in file space to dataptr. It had better be aligned. 143 */ 144 static inline xfs_dir2_dataptr_t 145 xfs_dir2_byte_to_dataptr(xfs_dir2_off_t by) 146 { 147 return (xfs_dir2_dataptr_t)(by >> XFS_DIR2_DATA_ALIGN_LOG); 148 } 149 150 /* 151 * Convert byte in space to (DB) block 152 */ 153 static inline xfs_dir2_db_t 154 xfs_dir2_byte_to_db(struct xfs_da_geometry *geo, xfs_dir2_off_t by) 155 { 156 return (xfs_dir2_db_t)(by >> geo->blklog); 157 } 158 159 /* 160 * Convert dataptr to a block number 161 */ 162 static inline xfs_dir2_db_t 163 xfs_dir2_dataptr_to_db(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp) 164 { 165 return xfs_dir2_byte_to_db(geo, xfs_dir2_dataptr_to_byte(dp)); 166 } 167 168 /* 169 * Convert byte in space to offset in a block 170 */ 171 static inline xfs_dir2_data_aoff_t 172 xfs_dir2_byte_to_off(struct xfs_da_geometry *geo, xfs_dir2_off_t by) 173 { 174 return (xfs_dir2_data_aoff_t)(by & (geo->blksize - 1)); 175 } 176 177 /* 178 * Convert dataptr to a byte offset in a block 179 */ 180 static inline xfs_dir2_data_aoff_t 181 xfs_dir2_dataptr_to_off(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp) 182 { 183 return xfs_dir2_byte_to_off(geo, xfs_dir2_dataptr_to_byte(dp)); 184 } 185 186 /* 187 * Convert block and offset to byte in space 188 */ 189 static inline xfs_dir2_off_t 190 xfs_dir2_db_off_to_byte(struct xfs_da_geometry *geo, xfs_dir2_db_t db, 191 xfs_dir2_data_aoff_t o) 192 { 193 return ((xfs_dir2_off_t)db << geo->blklog) + o; 194 } 195 196 /* 197 * Convert block (DB) to block (dablk) 198 */ 199 static inline xfs_dablk_t 200 xfs_dir2_db_to_da(struct xfs_da_geometry *geo, xfs_dir2_db_t db) 201 { 202 return (xfs_dablk_t)(db << (geo->blklog - geo->fsblog)); 203 } 204 205 /* 206 * Convert byte in space to (DA) block 207 */ 208 static inline xfs_dablk_t 209 xfs_dir2_byte_to_da(struct xfs_da_geometry *geo, xfs_dir2_off_t by) 210 { 211 return xfs_dir2_db_to_da(geo, xfs_dir2_byte_to_db(geo, by)); 212 } 213 214 /* 215 * Convert block and offset to dataptr 216 */ 217 static inline xfs_dir2_dataptr_t 218 xfs_dir2_db_off_to_dataptr(struct xfs_da_geometry *geo, xfs_dir2_db_t db, 219 xfs_dir2_data_aoff_t o) 220 { 221 return xfs_dir2_byte_to_dataptr(xfs_dir2_db_off_to_byte(geo, db, o)); 222 } 223 224 /* 225 * Convert block (dablk) to block (DB) 226 */ 227 static inline xfs_dir2_db_t 228 xfs_dir2_da_to_db(struct xfs_da_geometry *geo, xfs_dablk_t da) 229 { 230 return (xfs_dir2_db_t)(da >> (geo->blklog - geo->fsblog)); 231 } 232 233 /* 234 * Convert block (dablk) to byte offset in space 235 */ 236 static inline xfs_dir2_off_t 237 xfs_dir2_da_to_byte(struct xfs_da_geometry *geo, xfs_dablk_t da) 238 { 239 return xfs_dir2_db_off_to_byte(geo, xfs_dir2_da_to_db(geo, da), 0); 240 } 241 242 /* 243 * Directory tail pointer accessor functions. Based on block geometry. 244 */ 245 static inline struct xfs_dir2_block_tail * 246 xfs_dir2_block_tail_p(struct xfs_da_geometry *geo, struct xfs_dir2_data_hdr *hdr) 247 { 248 return ((struct xfs_dir2_block_tail *) 249 ((char *)hdr + geo->blksize)) - 1; 250 } 251 252 static inline struct xfs_dir2_leaf_tail * 253 xfs_dir2_leaf_tail_p(struct xfs_da_geometry *geo, struct xfs_dir2_leaf *lp) 254 { 255 return (struct xfs_dir2_leaf_tail *) 256 ((char *)lp + geo->blksize - 257 sizeof(struct xfs_dir2_leaf_tail)); 258 } 259 260 /* 261 * The Linux API doesn't pass down the total size of the buffer 262 * we read into down to the filesystem. With the filldir concept 263 * it's not needed for correct information, but the XFS dir2 leaf 264 * code wants an estimate of the buffer size to calculate it's 265 * readahead window and size the buffers used for mapping to 266 * physical blocks. 267 * 268 * Try to give it an estimate that's good enough, maybe at some 269 * point we can change the ->readdir prototype to include the 270 * buffer size. For now we use the current glibc buffer size. 271 * musl libc hardcodes 2k and dietlibc uses PAGE_SIZE. 272 */ 273 #define XFS_READDIR_BUFSIZE (32768) 274 275 unsigned char xfs_dir3_get_dtype(struct xfs_mount *mp, uint8_t filetype); 276 unsigned int xfs_dir3_data_end_offset(struct xfs_da_geometry *geo, 277 struct xfs_dir2_data_hdr *hdr); 278 bool xfs_dir2_namecheck(const void *name, size_t length); 279 280 /* 281 * The "ascii-ci" feature was created to speed up case-insensitive lookups for 282 * a Samba product. Because of the inherent problems with CI and UTF-8 283 * encoding, etc, it was decided that Samba would be configured to export 284 * latin1/iso 8859-1 encodings as that covered >90% of the target markets for 285 * the product. Hence the "ascii-ci" casefolding code could be encoded into 286 * the XFS directory operations and remove all the overhead of casefolding from 287 * Samba. 288 * 289 * To provide consistent hashing behavior between the userspace and kernel, 290 * these functions prepare names for hashing by transforming specific bytes 291 * to other bytes. Robustness with other encodings is not guaranteed. 292 */ 293 static inline bool xfs_ascii_ci_need_xfrm(unsigned char c) 294 { 295 if (c >= 0x41 && c <= 0x5a) /* A-Z */ 296 return true; 297 if (c >= 0xc0 && c <= 0xd6) /* latin A-O with accents */ 298 return true; 299 if (c >= 0xd8 && c <= 0xde) /* latin O-Y with accents */ 300 return true; 301 return false; 302 } 303 304 static inline unsigned char xfs_ascii_ci_xfrm(unsigned char c) 305 { 306 if (xfs_ascii_ci_need_xfrm(c)) 307 c -= 'A' - 'a'; 308 return c; 309 } 310 311 struct xfs_dir_update_params { 312 const struct xfs_inode *dp; 313 const struct xfs_inode *ip; 314 const struct xfs_name *name; 315 int delta; 316 }; 317 318 #ifdef CONFIG_XFS_LIVE_HOOKS 319 void xfs_dir_update_hook(struct xfs_inode *dp, struct xfs_inode *ip, 320 int delta, const struct xfs_name *name); 321 322 struct xfs_dir_hook { 323 struct xfs_hook dirent_hook; 324 }; 325 326 void xfs_dir_hook_disable(void); 327 void xfs_dir_hook_enable(void); 328 329 int xfs_dir_hook_add(struct xfs_mount *mp, struct xfs_dir_hook *hook); 330 void xfs_dir_hook_del(struct xfs_mount *mp, struct xfs_dir_hook *hook); 331 void xfs_dir_hook_setup(struct xfs_dir_hook *hook, notifier_fn_t mod_fn); 332 #else 333 # define xfs_dir_update_hook(dp, ip, delta, name) ((void)0) 334 #endif /* CONFIG_XFS_LIVE_HOOKS */ 335 336 struct xfs_parent_args; 337 338 struct xfs_dir_update { 339 struct xfs_inode *dp; 340 const struct xfs_name *name; 341 struct xfs_inode *ip; 342 struct xfs_parent_args *ppargs; 343 }; 344 345 int xfs_dir_create_child(struct xfs_trans *tp, unsigned int resblks, 346 struct xfs_dir_update *du); 347 int xfs_dir_add_child(struct xfs_trans *tp, unsigned int resblks, 348 struct xfs_dir_update *du); 349 int xfs_dir_remove_child(struct xfs_trans *tp, unsigned int resblks, 350 struct xfs_dir_update *du); 351 352 int xfs_dir_exchange_children(struct xfs_trans *tp, struct xfs_dir_update *du1, 353 struct xfs_dir_update *du2, unsigned int spaceres); 354 int xfs_dir_rename_children(struct xfs_trans *tp, struct xfs_dir_update *du_src, 355 struct xfs_dir_update *du_tgt, unsigned int spaceres, 356 struct xfs_dir_update *du_wip); 357 358 #endif /* __XFS_DIR2_H__ */ 359