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