fs/xfs/libxfs/xfs_dir2.h

   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
  26 /*
  27  * Convert inode mode to directory entry filetype
  28  */
  29 extern unsigned char xfs_mode_to_ftype(int mode);
  30
  31 /*
  32  * Generic directory interface routines
  33  */
  34 extern void xfs_dir_startup(void);
  35 extern int xfs_da_mount(struct xfs_mount *mp);
  36 extern void xfs_da_unmount(struct xfs_mount *mp);
  37
  38 extern int xfs_dir_isempty(struct xfs_inode *dp);
  39 extern int xfs_dir_init(struct xfs_trans *tp, struct xfs_inode *dp,
  40                                 struct xfs_inode *pdp);
  41 extern int xfs_dir_createname(struct xfs_trans *tp, struct xfs_inode *dp,
  42                                 const struct xfs_name *name, xfs_ino_t inum,
  43                                 xfs_extlen_t tot);
  44 extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp,
  45                                 const struct xfs_name *name, xfs_ino_t *inum,
  46                                 struct xfs_name *ci_name);
  47 extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
  48                                 struct xfs_name *name, xfs_ino_t ino,
  49                                 xfs_extlen_t tot);
  50 extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp,
  51                                 const struct xfs_name *name, xfs_ino_t inum,
  52                                 xfs_extlen_t tot);
  53 extern int xfs_dir_canenter(struct xfs_trans *tp, struct xfs_inode *dp,
  54                                 struct xfs_name *name);
  55
  56 /*
  57  * Direct call from the bmap code, bypassing the generic directory layer.
  58  */
  59 extern int xfs_dir2_sf_to_block(struct xfs_da_args *args);
  60
  61 /*
  62  * Interface routines used by userspace utilities
  63  */
  64 extern int xfs_dir2_isblock(struct xfs_da_args *args, bool *isblock);
  65 extern int xfs_dir2_isleaf(struct xfs_da_args *args, bool *isleaf);
  66 extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db,
  67                                 struct xfs_buf *bp);
  68
  69 extern void xfs_dir2_data_freescan(struct xfs_mount *mp,
  70                 struct xfs_dir2_data_hdr *hdr, int *loghead);
  71 extern void xfs_dir2_data_log_entry(struct xfs_da_args *args,
  72                 struct xfs_buf *bp, struct xfs_dir2_data_entry *dep);
  73 extern void xfs_dir2_data_log_header(struct xfs_da_args *args,
  74                 struct xfs_buf *bp);
  75 extern void xfs_dir2_data_log_unused(struct xfs_da_args *args,
  76                 struct xfs_buf *bp, struct xfs_dir2_data_unused *dup);
  77 extern void xfs_dir2_data_make_free(struct xfs_da_args *args,
  78                 struct xfs_buf *bp, xfs_dir2_data_aoff_t offset,
  79                 xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp);
  80 extern int xfs_dir2_data_use_free(struct xfs_da_args *args,
  81                 struct xfs_buf *bp, struct xfs_dir2_data_unused *dup,
  82                 xfs_dir2_data_aoff_t offset, xfs_dir2_data_aoff_t len,
  83                 int *needlogp, int *needscanp);
  84
  85 extern struct xfs_dir2_data_free *xfs_dir2_data_freefind(
  86                 struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_data_free *bf,
  87                 struct xfs_dir2_data_unused *dup);
  88
  89 extern int xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);
  90
  91 extern const struct xfs_buf_ops xfs_dir3_block_buf_ops;
  92 extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;
  93 extern const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops;
  94 extern const struct xfs_buf_ops xfs_dir3_free_buf_ops;
  95 extern const struct xfs_buf_ops xfs_dir3_data_buf_ops;
  96
  97 /*
  98  * Directory offset/block conversion functions.
  99  *
 100  * DB blocks here are logical directory block numbers, not filesystem blocks.
 101  */
 102
 103 /*
 104  * Convert dataptr to byte in file space
 105  */
 106 static inline xfs_dir2_off_t
 107 xfs_dir2_dataptr_to_byte(xfs_dir2_dataptr_t dp)
 108 {
 109         return (xfs_dir2_off_t)dp << XFS_DIR2_DATA_ALIGN_LOG;
 110 }
 111
 112 /*
 113  * Convert byte in file space to dataptr.  It had better be aligned.
 114  */
 115 static inline xfs_dir2_dataptr_t
 116 xfs_dir2_byte_to_dataptr(xfs_dir2_off_t by)
 117 {
 118         return (xfs_dir2_dataptr_t)(by >> XFS_DIR2_DATA_ALIGN_LOG);
 119 }
 120
 121 /*
 122  * Convert byte in space to (DB) block
 123  */
 124 static inline xfs_dir2_db_t
 125 xfs_dir2_byte_to_db(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
 126 {
 127         return (xfs_dir2_db_t)(by >> geo->blklog);
 128 }
 129
 130 /*
 131  * Convert dataptr to a block number
 132  */
 133 static inline xfs_dir2_db_t
 134 xfs_dir2_dataptr_to_db(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp)
 135 {
 136         return xfs_dir2_byte_to_db(geo, xfs_dir2_dataptr_to_byte(dp));
 137 }
 138
 139 /*
 140  * Convert byte in space to offset in a block
 141  */
 142 static inline xfs_dir2_data_aoff_t
 143 xfs_dir2_byte_to_off(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
 144 {
 145         return (xfs_dir2_data_aoff_t)(by & (geo->blksize - 1));
 146 }
 147
 148 /*
 149  * Convert dataptr to a byte offset in a block
 150  */
 151 static inline xfs_dir2_data_aoff_t
 152 xfs_dir2_dataptr_to_off(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp)
 153 {
 154         return xfs_dir2_byte_to_off(geo, xfs_dir2_dataptr_to_byte(dp));
 155 }
 156
 157 /*
 158  * Convert block and offset to byte in space
 159  */
 160 static inline xfs_dir2_off_t
 161 xfs_dir2_db_off_to_byte(struct xfs_da_geometry *geo, xfs_dir2_db_t db,
 162                         xfs_dir2_data_aoff_t o)
 163 {
 164         return ((xfs_dir2_off_t)db << geo->blklog) + o;
 165 }
 166
 167 /*
 168  * Convert block (DB) to block (dablk)
 169  */
 170 static inline xfs_dablk_t
 171 xfs_dir2_db_to_da(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
 172 {
 173         return (xfs_dablk_t)(db << (geo->blklog - geo->fsblog));
 174 }
 175
 176 /*
 177  * Convert byte in space to (DA) block
 178  */
 179 static inline xfs_dablk_t
 180 xfs_dir2_byte_to_da(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
 181 {
 182         return xfs_dir2_db_to_da(geo, xfs_dir2_byte_to_db(geo, by));
 183 }
 184
 185 /*
 186  * Convert block and offset to dataptr
 187  */
 188 static inline xfs_dir2_dataptr_t
 189 xfs_dir2_db_off_to_dataptr(struct xfs_da_geometry *geo, xfs_dir2_db_t db,
 190                            xfs_dir2_data_aoff_t o)
 191 {
 192         return xfs_dir2_byte_to_dataptr(xfs_dir2_db_off_to_byte(geo, db, o));
 193 }
 194
 195 /*
 196  * Convert block (dablk) to block (DB)
 197  */
 198 static inline xfs_dir2_db_t
 199 xfs_dir2_da_to_db(struct xfs_da_geometry *geo, xfs_dablk_t da)
 200 {
 201         return (xfs_dir2_db_t)(da >> (geo->blklog - geo->fsblog));
 202 }
 203
 204 /*
 205  * Convert block (dablk) to byte offset in space
 206  */
 207 static inline xfs_dir2_off_t
 208 xfs_dir2_da_to_byte(struct xfs_da_geometry *geo, xfs_dablk_t da)
 209 {
 210         return xfs_dir2_db_off_to_byte(geo, xfs_dir2_da_to_db(geo, da), 0);
 211 }
 212
 213 /*
 214  * Directory tail pointer accessor functions. Based on block geometry.
 215  */
 216 static inline struct xfs_dir2_block_tail *
 217 xfs_dir2_block_tail_p(struct xfs_da_geometry *geo, struct xfs_dir2_data_hdr *hdr)
 218 {
 219         return ((struct xfs_dir2_block_tail *)
 220                 ((char *)hdr + geo->blksize)) - 1;
 221 }
 222
 223 static inline struct xfs_dir2_leaf_tail *
 224 xfs_dir2_leaf_tail_p(struct xfs_da_geometry *geo, struct xfs_dir2_leaf *lp)
 225 {
 226         return (struct xfs_dir2_leaf_tail *)
 227                 ((char *)lp + geo->blksize -
 228                   sizeof(struct xfs_dir2_leaf_tail));
 229 }
 230
 231 /*
 232  * The Linux API doesn't pass down the total size of the buffer
 233  * we read into down to the filesystem.  With the filldir concept
 234  * it's not needed for correct information, but the XFS dir2 leaf
 235  * code wants an estimate of the buffer size to calculate it's
 236  * readahead window and size the buffers used for mapping to
 237  * physical blocks.
 238  *
 239  * Try to give it an estimate that's good enough, maybe at some
 240  * point we can change the ->readdir prototype to include the
 241  * buffer size.  For now we use the current glibc buffer size.
 242  * musl libc hardcodes 2k and dietlibc uses PAGE_SIZE.
 243  */
 244 #define XFS_READDIR_BUFSIZE     (32768)
 245
 246 unsigned char xfs_dir3_get_dtype(struct xfs_mount *mp, uint8_t filetype);
 247 unsigned int xfs_dir3_data_end_offset(struct xfs_da_geometry *geo,
 248                 struct xfs_dir2_data_hdr *hdr);
 249 bool xfs_dir2_namecheck(const void *name, size_t length);
 250
 251 /*
 252  * The "ascii-ci" feature was created to speed up case-insensitive lookups for
 253  * a Samba product.  Because of the inherent problems with CI and UTF-8
 254  * encoding, etc, it was decided that Samba would be configured to export
 255  * latin1/iso 8859-1 encodings as that covered >90% of the target markets for
 256  * the product.  Hence the "ascii-ci" casefolding code could be encoded into
 257  * the XFS directory operations and remove all the overhead of casefolding from
 258  * Samba.
 259  *
 260  * To provide consistent hashing behavior between the userspace and kernel,
 261  * these functions prepare names for hashing by transforming specific bytes
 262  * to other bytes.  Robustness with other encodings is not guaranteed.
 263  */
 264 static inline bool xfs_ascii_ci_need_xfrm(unsigned char c)
 265 {
 266         if (c >= 0x41 && c <= 0x5a)     /* A-Z */
 267                 return true;
 268         if (c >= 0xc0 && c <= 0xd6)     /* latin A-O with accents */
 269                 return true;
 270         if (c >= 0xd8 && c <= 0xde)     /* latin O-Y with accents */
 271                 return true;
 272         return false;
 273 }
 274
 275 static inline unsigned char xfs_ascii_ci_xfrm(unsigned char c)
 276 {
 277         if (xfs_ascii_ci_need_xfrm(c))
 278                 c -= 'A' - 'a';
 279         return c;
 280 }
 281
 282 #endif  /* __XFS_DIR2_H__ */