1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 4 * Copyright (c) 2013 Red Hat, Inc. 5 * All Rights Reserved. 6 */ 7 #include "xfs.h" 8 #include "xfs_fs.h" 9 #include "xfs_shared.h" 10 #include "xfs_format.h" 11 #include "xfs_log_format.h" 12 #include "xfs_trans_resv.h" 13 #include "xfs_mount.h" 14 #include "xfs_da_format.h" 15 #include "xfs_inode.h" 16 #include "xfs_trans.h" 17 #include "xfs_bmap.h" 18 #include "xfs_da_btree.h" 19 #include "xfs_attr.h" 20 #include "xfs_attr_sf.h" 21 #include "xfs_attr_leaf.h" 22 #include "xfs_error.h" 23 #include "xfs_trace.h" 24 #include "xfs_dir2.h" 25 #include "xfs_health.h" 26 27 STATIC int 28 xfs_attr_shortform_compare(const void *a, const void *b) 29 { 30 xfs_attr_sf_sort_t *sa, *sb; 31 32 sa = (xfs_attr_sf_sort_t *)a; 33 sb = (xfs_attr_sf_sort_t *)b; 34 if (sa->hash < sb->hash) { 35 return -1; 36 } else if (sa->hash > sb->hash) { 37 return 1; 38 } else { 39 return sa->entno - sb->entno; 40 } 41 } 42 43 #define XFS_ISRESET_CURSOR(cursor) \ 44 (!((cursor)->initted) && !((cursor)->hashval) && \ 45 !((cursor)->blkno) && !((cursor)->offset)) 46 /* 47 * Copy out entries of shortform attribute lists for attr_list(). 48 * Shortform attribute lists are not stored in hashval sorted order. 49 * If the output buffer is not large enough to hold them all, then 50 * we have to calculate each entries' hashvalue and sort them before 51 * we can begin returning them to the user. 52 */ 53 static int 54 xfs_attr_shortform_list( 55 struct xfs_attr_list_context *context) 56 { 57 struct xfs_attrlist_cursor_kern *cursor = &context->cursor; 58 struct xfs_inode *dp = context->dp; 59 struct xfs_attr_sf_sort *sbuf, *sbp; 60 struct xfs_attr_sf_hdr *sf = dp->i_af.if_data; 61 struct xfs_attr_sf_entry *sfe; 62 int sbsize, nsbuf, count, i; 63 int error = 0; 64 65 ASSERT(sf != NULL); 66 if (!sf->count) 67 return 0; 68 69 trace_xfs_attr_list_sf(context); 70 71 /* 72 * If the buffer is large enough and the cursor is at the start, 73 * do not bother with sorting since we will return everything in 74 * one buffer and another call using the cursor won't need to be 75 * made. 76 * Note the generous fudge factor of 16 overhead bytes per entry. 77 * If bufsize is zero then put_listent must be a search function 78 * and can just scan through what we have. 79 */ 80 if (context->bufsize == 0 || 81 (XFS_ISRESET_CURSOR(cursor) && 82 (dp->i_af.if_bytes + sf->count * 16) < context->bufsize)) { 83 for (i = 0, sfe = xfs_attr_sf_firstentry(sf); i < sf->count; i++) { 84 if (XFS_IS_CORRUPT(context->dp->i_mount, 85 !xfs_attr_namecheck(sfe->flags, 86 sfe->nameval, 87 sfe->namelen))) { 88 xfs_dirattr_mark_sick(context->dp, XFS_ATTR_FORK); 89 return -EFSCORRUPTED; 90 } 91 context->put_listent(context, 92 sfe->flags, 93 sfe->nameval, 94 (int)sfe->namelen, 95 &sfe->nameval[sfe->namelen], 96 (int)sfe->valuelen); 97 /* 98 * Either search callback finished early or 99 * didn't fit it all in the buffer after all. 100 */ 101 if (context->seen_enough) 102 break; 103 sfe = xfs_attr_sf_nextentry(sfe); 104 } 105 trace_xfs_attr_list_sf_all(context); 106 return 0; 107 } 108 109 /* do no more for a search callback */ 110 if (context->bufsize == 0) 111 return 0; 112 113 /* 114 * It didn't all fit, so we have to sort everything on hashval. 115 */ 116 sbsize = sf->count * sizeof(*sbuf); 117 sbp = sbuf = kmalloc(sbsize, 118 GFP_KERNEL | __GFP_NOLOCKDEP | __GFP_NOFAIL); 119 120 /* 121 * Scan the attribute list for the rest of the entries, storing 122 * the relevant info from only those that match into a buffer. 123 */ 124 nsbuf = 0; 125 for (i = 0, sfe = xfs_attr_sf_firstentry(sf); i < sf->count; i++) { 126 if (unlikely( 127 ((char *)sfe < (char *)sf) || 128 ((char *)sfe >= ((char *)sf + dp->i_af.if_bytes)) || 129 !xfs_attr_check_namespace(sfe->flags))) { 130 XFS_CORRUPTION_ERROR("xfs_attr_shortform_list", 131 XFS_ERRLEVEL_LOW, 132 context->dp->i_mount, sfe, 133 sizeof(*sfe)); 134 kfree(sbuf); 135 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 136 return -EFSCORRUPTED; 137 } 138 139 sbp->entno = i; 140 sbp->name = sfe->nameval; 141 sbp->namelen = sfe->namelen; 142 /* These are bytes, and both on-disk, don't endian-flip */ 143 sbp->value = &sfe->nameval[sfe->namelen]; 144 sbp->valuelen = sfe->valuelen; 145 sbp->flags = sfe->flags; 146 sbp->hash = xfs_attr_hashval(dp->i_mount, sfe->flags, 147 sfe->nameval, sfe->namelen, 148 sfe->nameval + sfe->namelen, 149 sfe->valuelen); 150 sfe = xfs_attr_sf_nextentry(sfe); 151 sbp++; 152 nsbuf++; 153 } 154 155 /* 156 * Sort the entries on hash then entno. 157 */ 158 xfs_sort(sbuf, nsbuf, sizeof(*sbuf), xfs_attr_shortform_compare); 159 160 /* 161 * Re-find our place IN THE SORTED LIST. 162 */ 163 count = 0; 164 cursor->initted = 1; 165 cursor->blkno = 0; 166 for (sbp = sbuf, i = 0; i < nsbuf; i++, sbp++) { 167 if (sbp->hash == cursor->hashval) { 168 if (cursor->offset == count) { 169 break; 170 } 171 count++; 172 } else if (sbp->hash > cursor->hashval) { 173 break; 174 } 175 } 176 if (i == nsbuf) 177 goto out; 178 179 /* 180 * Loop putting entries into the user buffer. 181 */ 182 for ( ; i < nsbuf; i++, sbp++) { 183 if (cursor->hashval != sbp->hash) { 184 cursor->hashval = sbp->hash; 185 cursor->offset = 0; 186 } 187 if (XFS_IS_CORRUPT(context->dp->i_mount, 188 !xfs_attr_namecheck(sbp->flags, sbp->name, 189 sbp->namelen))) { 190 xfs_dirattr_mark_sick(context->dp, XFS_ATTR_FORK); 191 error = -EFSCORRUPTED; 192 goto out; 193 } 194 context->put_listent(context, 195 sbp->flags, 196 sbp->name, 197 sbp->namelen, 198 sbp->value, 199 sbp->valuelen); 200 if (context->seen_enough) 201 break; 202 cursor->offset++; 203 } 204 out: 205 kfree(sbuf); 206 return error; 207 } 208 209 /* 210 * We didn't find the block & hash mentioned in the cursor state, so 211 * walk down the attr btree looking for the hash. 212 */ 213 STATIC int 214 xfs_attr_node_list_lookup( 215 struct xfs_attr_list_context *context, 216 struct xfs_attrlist_cursor_kern *cursor, 217 struct xfs_buf **pbp) 218 { 219 struct xfs_da3_icnode_hdr nodehdr; 220 struct xfs_da_intnode *node; 221 struct xfs_da_node_entry *btree; 222 struct xfs_inode *dp = context->dp; 223 struct xfs_mount *mp = dp->i_mount; 224 struct xfs_trans *tp = context->tp; 225 struct xfs_buf *bp; 226 xfs_failaddr_t fa; 227 int i; 228 int error = 0; 229 unsigned int expected_level = 0; 230 uint16_t magic; 231 232 ASSERT(*pbp == NULL); 233 cursor->blkno = 0; 234 for (;;) { 235 error = xfs_da3_node_read(tp, dp, cursor->blkno, &bp, 236 XFS_ATTR_FORK); 237 if (error) 238 return error; 239 node = bp->b_addr; 240 magic = be16_to_cpu(node->hdr.info.magic); 241 if (magic == XFS_ATTR_LEAF_MAGIC || 242 magic == XFS_ATTR3_LEAF_MAGIC) 243 break; 244 if (magic != XFS_DA_NODE_MAGIC && 245 magic != XFS_DA3_NODE_MAGIC) { 246 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, 247 node, sizeof(*node)); 248 goto out_corruptbuf; 249 } 250 251 fa = xfs_da3_node_header_check(bp, dp->i_ino); 252 if (fa) 253 goto out_corruptbuf; 254 255 xfs_da3_node_hdr_from_disk(mp, &nodehdr, node); 256 257 /* Tree taller than we can handle; bail out! */ 258 if (nodehdr.level >= XFS_DA_NODE_MAXDEPTH) 259 goto out_corruptbuf; 260 261 /* Check the level from the root node. */ 262 if (cursor->blkno == 0) 263 expected_level = nodehdr.level - 1; 264 else if (expected_level != nodehdr.level) 265 goto out_corruptbuf; 266 else 267 expected_level--; 268 269 btree = nodehdr.btree; 270 for (i = 0; i < nodehdr.count; btree++, i++) { 271 if (cursor->hashval <= be32_to_cpu(btree->hashval)) { 272 cursor->blkno = be32_to_cpu(btree->before); 273 trace_xfs_attr_list_node_descend(context, 274 btree); 275 break; 276 } 277 } 278 xfs_trans_brelse(tp, bp); 279 280 if (i == nodehdr.count) 281 return 0; 282 283 /* We can't point back to the root. */ 284 if (XFS_IS_CORRUPT(mp, cursor->blkno == 0)) { 285 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 286 return -EFSCORRUPTED; 287 } 288 } 289 290 fa = xfs_attr3_leaf_header_check(bp, dp->i_ino); 291 if (fa) { 292 __xfs_buf_mark_corrupt(bp, fa); 293 goto out_releasebuf; 294 } 295 296 if (expected_level != 0) 297 goto out_corruptbuf; 298 299 *pbp = bp; 300 return 0; 301 302 out_corruptbuf: 303 xfs_buf_mark_corrupt(bp); 304 out_releasebuf: 305 xfs_trans_brelse(tp, bp); 306 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 307 return -EFSCORRUPTED; 308 } 309 310 STATIC int 311 xfs_attr_node_list( 312 struct xfs_attr_list_context *context) 313 { 314 struct xfs_attrlist_cursor_kern *cursor = &context->cursor; 315 struct xfs_attr3_icleaf_hdr leafhdr; 316 struct xfs_attr_leafblock *leaf; 317 struct xfs_da_intnode *node; 318 struct xfs_buf *bp; 319 struct xfs_inode *dp = context->dp; 320 struct xfs_mount *mp = dp->i_mount; 321 xfs_failaddr_t fa; 322 int error = 0; 323 324 trace_xfs_attr_node_list(context); 325 326 cursor->initted = 1; 327 328 /* 329 * Do all sorts of validation on the passed-in cursor structure. 330 * If anything is amiss, ignore the cursor and look up the hashval 331 * starting from the btree root. 332 */ 333 bp = NULL; 334 if (cursor->blkno > 0) { 335 struct xfs_attr_leaf_entry *entries; 336 337 error = xfs_da3_node_read(context->tp, dp, cursor->blkno, &bp, 338 XFS_ATTR_FORK); 339 if (xfs_metadata_is_sick(error)) 340 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 341 if (error != 0 && error != -EFSCORRUPTED) 342 return error; 343 if (!bp) 344 goto need_lookup; 345 346 node = bp->b_addr; 347 switch (be16_to_cpu(node->hdr.info.magic)) { 348 case XFS_DA_NODE_MAGIC: 349 case XFS_DA3_NODE_MAGIC: 350 trace_xfs_attr_list_wrong_blk(context); 351 fa = xfs_da3_node_header_check(bp, dp->i_ino); 352 if (fa) { 353 __xfs_buf_mark_corrupt(bp, fa); 354 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 355 } 356 xfs_trans_brelse(context->tp, bp); 357 bp = NULL; 358 break; 359 case XFS_ATTR_LEAF_MAGIC: 360 case XFS_ATTR3_LEAF_MAGIC: 361 leaf = bp->b_addr; 362 fa = xfs_attr3_leaf_header_check(bp, dp->i_ino); 363 if (fa) { 364 __xfs_buf_mark_corrupt(bp, fa); 365 xfs_trans_brelse(context->tp, bp); 366 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 367 bp = NULL; 368 break; 369 } 370 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, 371 &leafhdr, leaf); 372 entries = xfs_attr3_leaf_entryp(leaf); 373 if (cursor->hashval > be32_to_cpu( 374 entries[leafhdr.count - 1].hashval)) { 375 trace_xfs_attr_list_wrong_blk(context); 376 xfs_trans_brelse(context->tp, bp); 377 bp = NULL; 378 } else if (cursor->hashval <= be32_to_cpu( 379 entries[0].hashval)) { 380 trace_xfs_attr_list_wrong_blk(context); 381 xfs_trans_brelse(context->tp, bp); 382 bp = NULL; 383 } 384 break; 385 default: 386 trace_xfs_attr_list_wrong_blk(context); 387 xfs_trans_brelse(context->tp, bp); 388 bp = NULL; 389 } 390 } 391 392 /* 393 * We did not find what we expected given the cursor's contents, 394 * so we start from the top and work down based on the hash value. 395 * Note that start of node block is same as start of leaf block. 396 */ 397 if (bp == NULL) { 398 need_lookup: 399 error = xfs_attr_node_list_lookup(context, cursor, &bp); 400 if (error || !bp) 401 return error; 402 } 403 ASSERT(bp != NULL); 404 405 /* 406 * Roll upward through the blocks, processing each leaf block in 407 * order. As long as there is space in the result buffer, keep 408 * adding the information. 409 */ 410 for (;;) { 411 leaf = bp->b_addr; 412 error = xfs_attr3_leaf_list_int(bp, context); 413 if (error) 414 break; 415 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf); 416 if (context->seen_enough || leafhdr.forw == 0) 417 break; 418 cursor->blkno = leafhdr.forw; 419 xfs_trans_brelse(context->tp, bp); 420 error = xfs_attr3_leaf_read(context->tp, dp, dp->i_ino, 421 cursor->blkno, &bp); 422 if (error) 423 return error; 424 } 425 xfs_trans_brelse(context->tp, bp); 426 return error; 427 } 428 429 /* 430 * Copy out attribute list entries for attr_list(), for leaf attribute lists. 431 */ 432 int 433 xfs_attr3_leaf_list_int( 434 struct xfs_buf *bp, 435 struct xfs_attr_list_context *context) 436 { 437 struct xfs_attrlist_cursor_kern *cursor = &context->cursor; 438 struct xfs_attr_leafblock *leaf; 439 struct xfs_attr3_icleaf_hdr ichdr; 440 struct xfs_attr_leaf_entry *entries; 441 struct xfs_attr_leaf_entry *entry; 442 int i; 443 struct xfs_mount *mp = context->dp->i_mount; 444 445 trace_xfs_attr_list_leaf(context); 446 447 leaf = bp->b_addr; 448 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf); 449 entries = xfs_attr3_leaf_entryp(leaf); 450 451 cursor->initted = 1; 452 453 /* 454 * Re-find our place in the leaf block if this is a new syscall. 455 */ 456 if (context->resynch) { 457 entry = &entries[0]; 458 for (i = 0; i < ichdr.count; entry++, i++) { 459 if (be32_to_cpu(entry->hashval) == cursor->hashval) { 460 if (cursor->offset == context->dupcnt) { 461 context->dupcnt = 0; 462 break; 463 } 464 context->dupcnt++; 465 } else if (be32_to_cpu(entry->hashval) > 466 cursor->hashval) { 467 context->dupcnt = 0; 468 break; 469 } 470 } 471 if (i == ichdr.count) { 472 trace_xfs_attr_list_notfound(context); 473 return 0; 474 } 475 } else { 476 entry = &entries[0]; 477 i = 0; 478 } 479 context->resynch = 0; 480 481 /* 482 * We have found our place, start copying out the new attributes. 483 */ 484 for (; i < ichdr.count; entry++, i++) { 485 char *name; 486 void *value; 487 int namelen, valuelen; 488 489 if (be32_to_cpu(entry->hashval) != cursor->hashval) { 490 cursor->hashval = be32_to_cpu(entry->hashval); 491 cursor->offset = 0; 492 } 493 494 if ((entry->flags & XFS_ATTR_INCOMPLETE) && 495 !context->allow_incomplete) 496 continue; 497 498 if (entry->flags & XFS_ATTR_LOCAL) { 499 xfs_attr_leaf_name_local_t *name_loc; 500 501 name_loc = xfs_attr3_leaf_name_local(leaf, i); 502 name = name_loc->nameval; 503 namelen = name_loc->namelen; 504 value = &name_loc->nameval[name_loc->namelen]; 505 valuelen = be16_to_cpu(name_loc->valuelen); 506 } else { 507 xfs_attr_leaf_name_remote_t *name_rmt; 508 509 name_rmt = xfs_attr3_leaf_name_remote(leaf, i); 510 name = name_rmt->name; 511 namelen = name_rmt->namelen; 512 value = NULL; 513 valuelen = be32_to_cpu(name_rmt->valuelen); 514 } 515 516 if (XFS_IS_CORRUPT(context->dp->i_mount, 517 !xfs_attr_namecheck(entry->flags, name, 518 namelen))) { 519 xfs_dirattr_mark_sick(context->dp, XFS_ATTR_FORK); 520 return -EFSCORRUPTED; 521 } 522 context->put_listent(context, entry->flags, 523 name, namelen, value, valuelen); 524 if (context->seen_enough) 525 break; 526 cursor->offset++; 527 } 528 trace_xfs_attr_list_leaf_end(context); 529 return 0; 530 } 531 532 /* 533 * Copy out attribute entries for attr_list(), for leaf attribute lists. 534 */ 535 STATIC int 536 xfs_attr_leaf_list( 537 struct xfs_attr_list_context *context) 538 { 539 struct xfs_buf *bp; 540 int error; 541 542 trace_xfs_attr_leaf_list(context); 543 544 context->cursor.blkno = 0; 545 error = xfs_attr3_leaf_read(context->tp, context->dp, 546 context->dp->i_ino, 0, &bp); 547 if (error) 548 return error; 549 550 error = xfs_attr3_leaf_list_int(bp, context); 551 xfs_trans_brelse(context->tp, bp); 552 return error; 553 } 554 555 int 556 xfs_attr_list_ilocked( 557 struct xfs_attr_list_context *context) 558 { 559 struct xfs_inode *dp = context->dp; 560 int error; 561 562 xfs_assert_ilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL); 563 564 /* 565 * Decide on what work routines to call based on the inode size. 566 */ 567 if (!xfs_inode_hasattr(dp)) 568 return 0; 569 if (dp->i_af.if_format == XFS_DINODE_FMT_LOCAL) 570 return xfs_attr_shortform_list(context); 571 572 /* Prerequisite for xfs_attr_is_leaf */ 573 error = xfs_iread_extents(NULL, dp, XFS_ATTR_FORK); 574 if (error) 575 return error; 576 577 if (xfs_attr_is_leaf(dp)) 578 return xfs_attr_leaf_list(context); 579 return xfs_attr_node_list(context); 580 } 581 582 int 583 xfs_attr_list( 584 struct xfs_attr_list_context *context) 585 { 586 struct xfs_inode *dp = context->dp; 587 uint lock_mode; 588 int error; 589 590 XFS_STATS_INC(dp->i_mount, xs_attr_list); 591 592 if (xfs_is_shutdown(dp->i_mount)) 593 return -EIO; 594 595 lock_mode = xfs_ilock_attr_map_shared(dp); 596 error = xfs_attr_list_ilocked(context); 597 xfs_iunlock(dp, lock_mode); 598 return error; 599 } 600