1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2022-2024 Oracle. 4 * All rights reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_format.h" 9 #include "xfs_da_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_shared.h" 12 #include "xfs_trans_resv.h" 13 #include "xfs_mount.h" 14 #include "xfs_bmap_btree.h" 15 #include "xfs_inode.h" 16 #include "xfs_error.h" 17 #include "xfs_trace.h" 18 #include "xfs_trans.h" 19 #include "xfs_da_btree.h" 20 #include "xfs_attr.h" 21 #include "xfs_dir2.h" 22 #include "xfs_dir2_priv.h" 23 #include "xfs_attr_sf.h" 24 #include "xfs_bmap.h" 25 #include "xfs_defer.h" 26 #include "xfs_log.h" 27 #include "xfs_xattr.h" 28 #include "xfs_parent.h" 29 #include "xfs_trans_space.h" 30 #include "xfs_attr_item.h" 31 #include "xfs_health.h" 32 33 struct kmem_cache *xfs_parent_args_cache; 34 35 /* 36 * Parent pointer attribute handling. 37 * 38 * Because the attribute name is a filename component, it will never be longer 39 * than 255 bytes and must not contain nulls or slashes. These are roughly the 40 * same constraints that apply to attribute names. 41 * 42 * The attribute value must always be a struct xfs_parent_rec. This means the 43 * attribute will never be in remote format because 12 bytes is nowhere near 44 * xfs_attr_leaf_entsize_local_max() (~75% of block size). 45 * 46 * Creating a new parent attribute will always create a new attribute - there 47 * should never, ever be an existing attribute in the tree for a new inode. 48 * ENOSPC behavior is problematic - creating the inode without the parent 49 * pointer is effectively a corruption, so we allow parent attribute creation 50 * to dip into the reserve block pool to avoid unexpected ENOSPC errors from 51 * occurring. 52 */ 53 54 /* Return true if parent pointer attr name is valid. */ 55 bool 56 xfs_parent_namecheck( 57 unsigned int attr_flags, 58 const void *name, 59 size_t length) 60 { 61 /* 62 * Parent pointers always use logged operations, so there should never 63 * be incomplete xattrs. 64 */ 65 if (attr_flags & XFS_ATTR_INCOMPLETE) 66 return false; 67 68 return xfs_dir2_namecheck(name, length); 69 } 70 71 /* Return true if parent pointer attr value is valid. */ 72 bool 73 xfs_parent_valuecheck( 74 struct xfs_mount *mp, 75 const void *value, 76 size_t valuelen) 77 { 78 const struct xfs_parent_rec *rec = value; 79 80 if (!xfs_has_parent(mp)) 81 return false; 82 83 /* The xattr value must be a parent record. */ 84 if (valuelen != sizeof(struct xfs_parent_rec)) 85 return false; 86 87 /* The parent record must be local. */ 88 if (value == NULL) 89 return false; 90 91 /* The parent inumber must be valid. */ 92 if (!xfs_verify_dir_ino(mp, be64_to_cpu(rec->p_ino))) 93 return false; 94 95 return true; 96 } 97 98 /* Compute the attribute name hash for a parent pointer. */ 99 xfs_dahash_t 100 xfs_parent_hashval( 101 struct xfs_mount *mp, 102 const uint8_t *name, 103 int namelen, 104 xfs_ino_t parent_ino) 105 { 106 struct xfs_name xname = { 107 .name = name, 108 .len = namelen, 109 }; 110 111 /* 112 * Use the same dirent name hash as would be used on the directory, but 113 * mix in the parent inode number to avoid collisions on hardlinked 114 * files with identical names but different parents. 115 */ 116 return xfs_dir2_hashname(mp, &xname) ^ 117 upper_32_bits(parent_ino) ^ lower_32_bits(parent_ino); 118 } 119 120 /* Compute the attribute name hash from the xattr components. */ 121 xfs_dahash_t 122 xfs_parent_hashattr( 123 struct xfs_mount *mp, 124 const uint8_t *name, 125 int namelen, 126 const void *value, 127 int valuelen) 128 { 129 const struct xfs_parent_rec *rec = value; 130 131 /* Requires a local attr value in xfs_parent_rec format */ 132 if (valuelen != sizeof(struct xfs_parent_rec)) { 133 ASSERT(valuelen == sizeof(struct xfs_parent_rec)); 134 return 0; 135 } 136 137 if (!value) { 138 ASSERT(value != NULL); 139 return 0; 140 } 141 142 return xfs_parent_hashval(mp, name, namelen, be64_to_cpu(rec->p_ino)); 143 } 144 145 /* 146 * Initialize the parent pointer arguments structure. Caller must have zeroed 147 * the contents of @args. @tp is only required for updates. 148 */ 149 static void 150 xfs_parent_da_args_init( 151 struct xfs_da_args *args, 152 struct xfs_trans *tp, 153 struct xfs_parent_rec *rec, 154 struct xfs_inode *child, 155 xfs_ino_t owner, 156 const struct xfs_name *parent_name) 157 { 158 args->geo = child->i_mount->m_attr_geo; 159 args->whichfork = XFS_ATTR_FORK; 160 args->attr_filter = XFS_ATTR_PARENT; 161 args->op_flags = XFS_DA_OP_LOGGED | XFS_DA_OP_OKNOENT; 162 args->trans = tp; 163 args->dp = child; 164 args->owner = owner; 165 args->name = parent_name->name; 166 args->namelen = parent_name->len; 167 args->value = rec; 168 args->valuelen = sizeof(struct xfs_parent_rec); 169 xfs_attr_sethash(args); 170 } 171 172 /* Make sure the incore state is ready for a parent pointer query/update. */ 173 static inline int 174 xfs_parent_iread_extents( 175 struct xfs_trans *tp, 176 struct xfs_inode *child) 177 { 178 /* Parent pointers require that the attr fork must exist. */ 179 if (XFS_IS_CORRUPT(child->i_mount, !xfs_inode_has_attr_fork(child))) { 180 xfs_inode_mark_sick(child, XFS_SICK_INO_PARENT); 181 return -EFSCORRUPTED; 182 } 183 184 return xfs_iread_extents(tp, child, XFS_ATTR_FORK); 185 } 186 187 /* Add a parent pointer to reflect a dirent addition. */ 188 int 189 xfs_parent_addname( 190 struct xfs_trans *tp, 191 struct xfs_parent_args *ppargs, 192 struct xfs_inode *dp, 193 const struct xfs_name *parent_name, 194 struct xfs_inode *child) 195 { 196 int error; 197 198 error = xfs_parent_iread_extents(tp, child); 199 if (error) 200 return error; 201 202 xfs_inode_to_parent_rec(&ppargs->rec, dp); 203 xfs_parent_da_args_init(&ppargs->args, tp, &ppargs->rec, child, 204 child->i_ino, parent_name); 205 xfs_attr_defer_add(&ppargs->args, XFS_ATTR_DEFER_SET); 206 return 0; 207 } 208 209 /* Remove a parent pointer to reflect a dirent removal. */ 210 int 211 xfs_parent_removename( 212 struct xfs_trans *tp, 213 struct xfs_parent_args *ppargs, 214 struct xfs_inode *dp, 215 const struct xfs_name *parent_name, 216 struct xfs_inode *child) 217 { 218 int error; 219 220 error = xfs_parent_iread_extents(tp, child); 221 if (error) 222 return error; 223 224 xfs_inode_to_parent_rec(&ppargs->rec, dp); 225 xfs_parent_da_args_init(&ppargs->args, tp, &ppargs->rec, child, 226 child->i_ino, parent_name); 227 xfs_attr_defer_add(&ppargs->args, XFS_ATTR_DEFER_REMOVE); 228 return 0; 229 } 230 231 /* Replace one parent pointer with another to reflect a rename. */ 232 int 233 xfs_parent_replacename( 234 struct xfs_trans *tp, 235 struct xfs_parent_args *ppargs, 236 struct xfs_inode *old_dp, 237 const struct xfs_name *old_name, 238 struct xfs_inode *new_dp, 239 const struct xfs_name *new_name, 240 struct xfs_inode *child) 241 { 242 int error; 243 244 error = xfs_parent_iread_extents(tp, child); 245 if (error) 246 return error; 247 248 xfs_inode_to_parent_rec(&ppargs->rec, old_dp); 249 xfs_parent_da_args_init(&ppargs->args, tp, &ppargs->rec, child, 250 child->i_ino, old_name); 251 252 xfs_inode_to_parent_rec(&ppargs->new_rec, new_dp); 253 ppargs->args.new_name = new_name->name; 254 ppargs->args.new_namelen = new_name->len; 255 ppargs->args.new_value = &ppargs->new_rec; 256 ppargs->args.new_valuelen = sizeof(struct xfs_parent_rec); 257 xfs_attr_defer_add(&ppargs->args, XFS_ATTR_DEFER_REPLACE); 258 return 0; 259 } 260 261 /* 262 * Extract parent pointer information from any parent pointer xattr into 263 * @parent_ino/gen. The last two parameters can be NULL pointers. 264 * 265 * Returns 0 if this is not a parent pointer xattr at all; or -EFSCORRUPTED for 266 * garbage. 267 */ 268 int 269 xfs_parent_from_attr( 270 struct xfs_mount *mp, 271 unsigned int attr_flags, 272 const unsigned char *name, 273 unsigned int namelen, 274 const void *value, 275 unsigned int valuelen, 276 xfs_ino_t *parent_ino, 277 uint32_t *parent_gen) 278 { 279 const struct xfs_parent_rec *rec = value; 280 281 ASSERT(attr_flags & XFS_ATTR_PARENT); 282 283 if (!xfs_parent_namecheck(attr_flags, name, namelen)) 284 return -EFSCORRUPTED; 285 if (!xfs_parent_valuecheck(mp, value, valuelen)) 286 return -EFSCORRUPTED; 287 288 if (parent_ino) 289 *parent_ino = be64_to_cpu(rec->p_ino); 290 if (parent_gen) 291 *parent_gen = be32_to_cpu(rec->p_gen); 292 return 0; 293 } 294 295 /* 296 * Look up a parent pointer record (@parent_name -> @pptr) of @ip. 297 * 298 * Caller must hold at least ILOCK_SHARED. The scratchpad need not be 299 * initialized. 300 * 301 * Returns 0 if the pointer is found, -ENOATTR if there is no match, or a 302 * negative errno. 303 */ 304 int 305 xfs_parent_lookup( 306 struct xfs_trans *tp, 307 struct xfs_inode *ip, 308 const struct xfs_name *parent_name, 309 struct xfs_parent_rec *pptr, 310 struct xfs_da_args *scratch) 311 { 312 memset(scratch, 0, sizeof(struct xfs_da_args)); 313 xfs_parent_da_args_init(scratch, tp, pptr, ip, ip->i_ino, parent_name); 314 return xfs_attr_get_ilocked(scratch); 315 } 316 317 /* Sanity-check a parent pointer before we try to perform repairs. */ 318 static inline bool 319 xfs_parent_sanity_check( 320 struct xfs_mount *mp, 321 const struct xfs_name *parent_name, 322 const struct xfs_parent_rec *pptr) 323 { 324 if (!xfs_parent_namecheck(XFS_ATTR_PARENT, parent_name->name, 325 parent_name->len)) 326 return false; 327 328 if (!xfs_parent_valuecheck(mp, pptr, sizeof(*pptr))) 329 return false; 330 331 return true; 332 } 333 334 335 /* 336 * Attach the parent pointer (@parent_name -> @pptr) to @ip immediately. 337 * Caller must not have a transaction or hold the ILOCK. This is for 338 * specialized repair functions only. The scratchpad need not be initialized. 339 */ 340 int 341 xfs_parent_set( 342 struct xfs_inode *ip, 343 xfs_ino_t owner, 344 const struct xfs_name *parent_name, 345 struct xfs_parent_rec *pptr, 346 struct xfs_da_args *scratch) 347 { 348 if (!xfs_parent_sanity_check(ip->i_mount, parent_name, pptr)) { 349 ASSERT(0); 350 return -EFSCORRUPTED; 351 } 352 353 memset(scratch, 0, sizeof(struct xfs_da_args)); 354 xfs_parent_da_args_init(scratch, NULL, pptr, ip, owner, parent_name); 355 return xfs_attr_set(scratch, XFS_ATTRUPDATE_CREATE, false); 356 } 357 358 /* 359 * Remove the parent pointer (@parent_name -> @pptr) from @ip immediately. 360 * Caller must not have a transaction or hold the ILOCK. This is for 361 * specialized repair functions only. The scratchpad need not be initialized. 362 */ 363 int 364 xfs_parent_unset( 365 struct xfs_inode *ip, 366 xfs_ino_t owner, 367 const struct xfs_name *parent_name, 368 struct xfs_parent_rec *pptr, 369 struct xfs_da_args *scratch) 370 { 371 if (!xfs_parent_sanity_check(ip->i_mount, parent_name, pptr)) { 372 ASSERT(0); 373 return -EFSCORRUPTED; 374 } 375 376 memset(scratch, 0, sizeof(struct xfs_da_args)); 377 xfs_parent_da_args_init(scratch, NULL, pptr, ip, owner, parent_name); 378 return xfs_attr_set(scratch, XFS_ATTRUPDATE_REMOVE, false); 379 } 380