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