1 /*- 2 * Copyright (c) 2017, Fedor Uporov 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 */ 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/types.h> 32 #include <sys/kernel.h> 33 #include <sys/malloc.h> 34 #include <sys/vnode.h> 35 #include <sys/bio.h> 36 #include <sys/buf.h> 37 #include <sys/endian.h> 38 #include <sys/conf.h> 39 #include <sys/extattr.h> 40 41 #include <fs/ext2fs/fs.h> 42 #include <fs/ext2fs/ext2fs.h> 43 #include <fs/ext2fs/inode.h> 44 #include <fs/ext2fs/ext2_dinode.h> 45 #include <fs/ext2fs/ext2_mount.h> 46 #include <fs/ext2fs/ext2_extattr.h> 47 #include <fs/ext2fs/ext2_extern.h> 48 49 static int 50 ext2_extattr_attrnamespace_to_bsd(int attrnamespace) 51 { 52 53 switch (attrnamespace) { 54 case EXT4_XATTR_INDEX_SYSTEM: 55 return (EXTATTR_NAMESPACE_SYSTEM); 56 57 case EXT4_XATTR_INDEX_USER: 58 return (EXTATTR_NAMESPACE_USER); 59 60 case EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT: 61 return (POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE); 62 63 case EXT4_XATTR_INDEX_POSIX_ACL_ACCESS: 64 return (POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE); 65 } 66 67 return (EXTATTR_NAMESPACE_EMPTY); 68 } 69 70 static const char * 71 ext2_extattr_name_to_bsd(int attrnamespace, const char *name, int* name_len) 72 { 73 74 if (attrnamespace == EXT4_XATTR_INDEX_SYSTEM) 75 return (name); 76 else if (attrnamespace == EXT4_XATTR_INDEX_USER) 77 return (name); 78 else if (attrnamespace == EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT) { 79 *name_len = strlen(POSIX1E_ACL_DEFAULT_EXTATTR_NAME); 80 return (POSIX1E_ACL_DEFAULT_EXTATTR_NAME); 81 } else if (attrnamespace == EXT4_XATTR_INDEX_POSIX_ACL_ACCESS) { 82 *name_len = strlen(POSIX1E_ACL_ACCESS_EXTATTR_NAME); 83 return (POSIX1E_ACL_ACCESS_EXTATTR_NAME); 84 } 85 86 /* 87 * XXX: Not all linux namespaces are mapped to bsd for now, 88 * return NULL, which will be converted to ENOTSUP on upper layer. 89 */ 90 #ifdef EXT2FS_DEBUG 91 printf("can not convert ext2fs name to bsd: namespace=%d\n", attrnamespace); 92 #endif /* DEBUG */ 93 94 return (NULL); 95 } 96 97 static int 98 ext2_extattr_attrnamespace_to_linux(int attrnamespace, const char *name) 99 { 100 101 if (attrnamespace == POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE && 102 !strcmp(name, POSIX1E_ACL_DEFAULT_EXTATTR_NAME)) 103 return (EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT); 104 105 if (attrnamespace == POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE && 106 !strcmp(name, POSIX1E_ACL_ACCESS_EXTATTR_NAME)) 107 return (EXT4_XATTR_INDEX_POSIX_ACL_ACCESS); 108 109 switch (attrnamespace) { 110 case EXTATTR_NAMESPACE_SYSTEM: 111 return (EXT4_XATTR_INDEX_SYSTEM); 112 113 case EXTATTR_NAMESPACE_USER: 114 return (EXT4_XATTR_INDEX_USER); 115 } 116 117 /* 118 * In this case namespace conversion should be unique, 119 * so this point is unreachable. 120 */ 121 return (-1); 122 } 123 124 static const char * 125 ext2_extattr_name_to_linux(int attrnamespace, const char *name) 126 { 127 128 if (attrnamespace == POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE || 129 attrnamespace == POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE) 130 return (""); 131 else 132 return (name); 133 } 134 135 int 136 ext2_extattr_valid_attrname(int attrnamespace, const char *attrname) 137 { 138 if (attrnamespace == EXTATTR_NAMESPACE_EMPTY) 139 return (EINVAL); 140 141 if (strlen(attrname) == 0) 142 return (EINVAL); 143 144 if (strlen(attrname) + 1 > EXT2_EXTATTR_NAMELEN_MAX) 145 return (ENAMETOOLONG); 146 147 return (0); 148 } 149 150 static int 151 ext2_extattr_check(struct ext2fs_extattr_entry *entry, char *end) 152 { 153 struct ext2fs_extattr_entry *next; 154 155 while (!EXT2_IS_LAST_ENTRY(entry)) { 156 next = EXT2_EXTATTR_NEXT(entry); 157 if ((char *)next >= end) 158 return (EIO); 159 160 entry = next; 161 } 162 163 return (0); 164 } 165 166 int 167 ext2_extattr_inode_list(struct inode *ip, int attrnamespace, 168 struct uio *uio, size_t *size) 169 { 170 struct m_ext2fs *fs; 171 struct buf *bp; 172 struct ext2fs_extattr_dinode_header *header; 173 struct ext2fs_extattr_entry *entry; 174 const char *attr_name; 175 int name_len; 176 int error; 177 178 fs = ip->i_e2fs; 179 180 if ((error = bread(ip->i_devvp, 181 fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), 182 (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) { 183 brelse(bp); 184 return (error); 185 } 186 187 struct ext2fs_dinode *dinode = (struct ext2fs_dinode *) 188 ((char *)bp->b_data + 189 EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)); 190 191 /* Check attributes magic value */ 192 header = (struct ext2fs_extattr_dinode_header *)((char *)dinode + 193 E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize); 194 195 if (header->h_magic != EXTATTR_MAGIC) { 196 brelse(bp); 197 return (0); 198 } 199 200 error = ext2_extattr_check(EXT2_IFIRST(header), 201 (char *)dinode + EXT2_INODE_SIZE(fs)); 202 if (error) { 203 brelse(bp); 204 return (error); 205 } 206 207 for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); 208 entry = EXT2_EXTATTR_NEXT(entry)) { 209 if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) != 210 attrnamespace) 211 continue; 212 213 name_len = entry->e_name_len; 214 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 215 entry->e_name, &name_len); 216 if (!attr_name) { 217 brelse(bp); 218 return (ENOTSUP); 219 } 220 221 if (uio == NULL) 222 *size += name_len + 1; 223 else { 224 char *name = malloc(name_len + 1, M_TEMP, M_WAITOK); 225 name[0] = name_len; 226 memcpy(&name[1], attr_name, name_len); 227 error = uiomove(name, name_len + 1, uio); 228 free(name, M_TEMP); 229 if (error) 230 break; 231 } 232 } 233 234 brelse(bp); 235 236 return (error); 237 } 238 239 int 240 ext2_extattr_block_list(struct inode *ip, int attrnamespace, 241 struct uio *uio, size_t *size) 242 { 243 struct m_ext2fs *fs; 244 struct buf *bp; 245 struct ext2fs_extattr_header *header; 246 struct ext2fs_extattr_entry *entry; 247 const char *attr_name; 248 int name_len; 249 int error; 250 251 fs = ip->i_e2fs; 252 253 error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl), 254 fs->e2fs_bsize, NOCRED, &bp); 255 if (error) { 256 brelse(bp); 257 return (error); 258 } 259 260 /* Check attributes magic value */ 261 header = EXT2_HDR(bp); 262 if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) { 263 brelse(bp); 264 return (EINVAL); 265 } 266 267 error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); 268 if (error) { 269 brelse(bp); 270 return (error); 271 } 272 273 for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); 274 entry = EXT2_EXTATTR_NEXT(entry)) { 275 if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) != 276 attrnamespace) 277 continue; 278 279 name_len = entry->e_name_len; 280 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 281 entry->e_name, &name_len); 282 if (!attr_name) { 283 brelse(bp); 284 return (ENOTSUP); 285 } 286 287 if (uio == NULL) 288 *size += name_len + 1; 289 else { 290 char *name = malloc(name_len + 1, M_TEMP, M_WAITOK); 291 name[0] = name_len; 292 memcpy(&name[1], attr_name, name_len); 293 error = uiomove(name, name_len + 1, uio); 294 free(name, M_TEMP); 295 if (error) 296 break; 297 } 298 } 299 300 brelse(bp); 301 302 return (error); 303 } 304 305 int 306 ext2_extattr_inode_get(struct inode *ip, int attrnamespace, 307 const char *name, struct uio *uio, size_t *size) 308 { 309 struct m_ext2fs *fs; 310 struct buf *bp; 311 struct ext2fs_extattr_dinode_header *header; 312 struct ext2fs_extattr_entry *entry; 313 const char *attr_name; 314 int name_len; 315 int error; 316 317 fs = ip->i_e2fs; 318 319 if ((error = bread(ip->i_devvp, 320 fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), 321 (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) { 322 brelse(bp); 323 return (error); 324 } 325 326 struct ext2fs_dinode *dinode = (struct ext2fs_dinode *) 327 ((char *)bp->b_data + 328 EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)); 329 330 /* Check attributes magic value */ 331 header = (struct ext2fs_extattr_dinode_header *)((char *)dinode + 332 E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize); 333 334 if (header->h_magic != EXTATTR_MAGIC) { 335 brelse(bp); 336 return (ENOATTR); 337 } 338 339 error = ext2_extattr_check(EXT2_IFIRST(header), 340 (char *)dinode + EXT2_INODE_SIZE(fs)); 341 if (error) { 342 brelse(bp); 343 return (error); 344 } 345 346 for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); 347 entry = EXT2_EXTATTR_NEXT(entry)) { 348 if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) != 349 attrnamespace) 350 continue; 351 352 name_len = entry->e_name_len; 353 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 354 entry->e_name, &name_len); 355 if (!attr_name) { 356 brelse(bp); 357 return (ENOTSUP); 358 } 359 360 if (strlen(name) == name_len && 361 0 == strncmp(attr_name, name, name_len)) { 362 if (uio == NULL) 363 *size += entry->e_value_size; 364 else { 365 error = uiomove(((char *)EXT2_IFIRST(header)) + 366 entry->e_value_offs, entry->e_value_size, uio); 367 } 368 369 brelse(bp); 370 return (error); 371 } 372 } 373 374 brelse(bp); 375 376 return (ENOATTR); 377 } 378 379 int 380 ext2_extattr_block_get(struct inode *ip, int attrnamespace, 381 const char *name, struct uio *uio, size_t *size) 382 { 383 struct m_ext2fs *fs; 384 struct buf *bp; 385 struct ext2fs_extattr_header *header; 386 struct ext2fs_extattr_entry *entry; 387 const char *attr_name; 388 int name_len; 389 int error; 390 391 fs = ip->i_e2fs; 392 393 error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl), 394 fs->e2fs_bsize, NOCRED, &bp); 395 if (error) { 396 brelse(bp); 397 return (error); 398 } 399 400 /* Check attributes magic value */ 401 header = EXT2_HDR(bp); 402 if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) { 403 brelse(bp); 404 return (EINVAL); 405 } 406 407 error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); 408 if (error) { 409 brelse(bp); 410 return (error); 411 } 412 413 for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); 414 entry = EXT2_EXTATTR_NEXT(entry)) { 415 if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) != 416 attrnamespace) 417 continue; 418 419 name_len = entry->e_name_len; 420 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 421 entry->e_name, &name_len); 422 if (!attr_name) { 423 brelse(bp); 424 return (ENOTSUP); 425 } 426 427 if (strlen(name) == name_len && 428 0 == strncmp(attr_name, name, name_len)) { 429 if (uio == NULL) 430 *size += entry->e_value_size; 431 else { 432 error = uiomove(bp->b_data + entry->e_value_offs, 433 entry->e_value_size, uio); 434 } 435 436 brelse(bp); 437 return (error); 438 } 439 } 440 441 brelse(bp); 442 443 return (ENOATTR); 444 } 445 446 static uint16_t 447 ext2_extattr_delete_value(char *off, 448 struct ext2fs_extattr_entry *first_entry, 449 struct ext2fs_extattr_entry *entry, char *end) 450 { 451 uint16_t min_offs; 452 struct ext2fs_extattr_entry *next; 453 454 min_offs = end - off; 455 next = first_entry; 456 while (!EXT2_IS_LAST_ENTRY(next)) { 457 if (min_offs > next->e_value_offs && next->e_value_offs > 0) 458 min_offs = next->e_value_offs; 459 460 next = EXT2_EXTATTR_NEXT(next); 461 } 462 463 if (entry->e_value_size == 0) 464 return (min_offs); 465 466 memmove(off + min_offs + EXT2_EXTATTR_SIZE(entry->e_value_size), 467 off + min_offs, entry->e_value_offs - min_offs); 468 469 /* Adjust all value offsets */ 470 next = first_entry; 471 while (!EXT2_IS_LAST_ENTRY(next)) 472 { 473 if (next->e_value_offs > 0 && 474 next->e_value_offs < entry->e_value_offs) 475 next->e_value_offs += 476 EXT2_EXTATTR_SIZE(entry->e_value_size); 477 478 next = EXT2_EXTATTR_NEXT(next); 479 } 480 481 min_offs += EXT2_EXTATTR_SIZE(entry->e_value_size); 482 483 return (min_offs); 484 } 485 486 static void 487 ext2_extattr_delete_entry(char *off, 488 struct ext2fs_extattr_entry *first_entry, 489 struct ext2fs_extattr_entry *entry, char *end) 490 { 491 char *pad; 492 struct ext2fs_extattr_entry *next; 493 494 /* Clean entry value */ 495 ext2_extattr_delete_value(off, first_entry, entry, end); 496 497 /* Clean the entry */ 498 next = first_entry; 499 while (!EXT2_IS_LAST_ENTRY(next)) 500 next = EXT2_EXTATTR_NEXT(next); 501 502 pad = (char*)next + sizeof(uint32_t); 503 504 memmove(entry, (char *)entry + EXT2_EXTATTR_LEN(entry->e_name_len), 505 pad - ((char *)entry + EXT2_EXTATTR_LEN(entry->e_name_len))); 506 } 507 508 int 509 ext2_extattr_inode_delete(struct inode *ip, int attrnamespace, const char *name) 510 { 511 struct m_ext2fs *fs; 512 struct buf *bp; 513 struct ext2fs_extattr_dinode_header *header; 514 struct ext2fs_extattr_entry *entry; 515 const char *attr_name; 516 int name_len; 517 int error; 518 519 fs = ip->i_e2fs; 520 521 if ((error = bread(ip->i_devvp, 522 fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), 523 (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) { 524 brelse(bp); 525 return (error); 526 } 527 528 struct ext2fs_dinode *dinode = (struct ext2fs_dinode *) 529 ((char *)bp->b_data + 530 EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)); 531 532 /* Check attributes magic value */ 533 header = (struct ext2fs_extattr_dinode_header *)((char *)dinode + 534 E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize); 535 536 if (header->h_magic != EXTATTR_MAGIC) { 537 brelse(bp); 538 return (ENOATTR); 539 } 540 541 error = ext2_extattr_check(EXT2_IFIRST(header), 542 (char *)dinode + EXT2_INODE_SIZE(fs)); 543 if (error) { 544 brelse(bp); 545 return (error); 546 } 547 548 /* If I am last entry, just make magic zero */ 549 entry = EXT2_IFIRST(header); 550 if ((EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry))) && 551 (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) == 552 attrnamespace)) { 553 554 name_len = entry->e_name_len; 555 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 556 entry->e_name, &name_len); 557 if (!attr_name) { 558 brelse(bp); 559 return (ENOTSUP); 560 } 561 562 if (strlen(name) == name_len && 563 0 == strncmp(attr_name, name, name_len)) { 564 memset(header, 0, sizeof(struct ext2fs_extattr_dinode_header)); 565 566 return (bwrite(bp)); 567 } 568 } 569 570 for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); 571 entry = EXT2_EXTATTR_NEXT(entry)) { 572 if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) != 573 attrnamespace) 574 continue; 575 576 name_len = entry->e_name_len; 577 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 578 entry->e_name, &name_len); 579 if (!attr_name) { 580 brelse(bp); 581 return (ENOTSUP); 582 } 583 584 if (strlen(name) == name_len && 585 0 == strncmp(attr_name, name, name_len)) { 586 ext2_extattr_delete_entry((char *)EXT2_IFIRST(header), 587 EXT2_IFIRST(header), entry, 588 (char *)dinode + EXT2_INODE_SIZE(fs)); 589 590 return (bwrite(bp)); 591 } 592 } 593 594 brelse(bp); 595 596 return (ENOATTR); 597 } 598 599 static int 600 ext2_extattr_block_clone(struct inode *ip, struct buf **bpp) 601 { 602 struct m_ext2fs *fs; 603 struct buf *sbp; 604 struct buf *cbp; 605 struct ext2fs_extattr_header *header; 606 uint64_t facl; 607 608 fs = ip->i_e2fs; 609 sbp = *bpp; 610 611 header = EXT2_HDR(sbp); 612 if (header->h_magic != EXTATTR_MAGIC || header->h_refcount == 1) 613 return (EINVAL); 614 615 facl = ext2_allocfacl(ip); 616 if (!facl) 617 return (ENOSPC); 618 619 cbp = getblk(ip->i_devvp, fsbtodb(fs, facl), fs->e2fs_bsize, 0, 0, 0); 620 if (!cbp) { 621 ext2_blkfree(ip, facl, fs->e2fs_bsize); 622 return (EIO); 623 } 624 625 memcpy(cbp->b_data, sbp->b_data, fs->e2fs_bsize); 626 header->h_refcount--; 627 bwrite(sbp); 628 629 ip->i_facl = facl; 630 ext2_update(ip->i_vnode, 1); 631 632 header = EXT2_HDR(cbp); 633 header->h_refcount = 1; 634 635 *bpp = cbp; 636 637 return (0); 638 } 639 640 int 641 ext2_extattr_block_delete(struct inode *ip, int attrnamespace, const char *name) 642 { 643 struct m_ext2fs *fs; 644 struct buf *bp; 645 struct ext2fs_extattr_header *header; 646 struct ext2fs_extattr_entry *entry; 647 const char *attr_name; 648 int name_len; 649 int error; 650 651 fs = ip->i_e2fs; 652 653 error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl), 654 fs->e2fs_bsize, NOCRED, &bp); 655 if (error) { 656 brelse(bp); 657 return (error); 658 } 659 660 /* Check attributes magic value */ 661 header = EXT2_HDR(bp); 662 if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) { 663 brelse(bp); 664 return (EINVAL); 665 } 666 667 error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); 668 if (error) { 669 brelse(bp); 670 return (error); 671 } 672 673 if (header->h_refcount > 1) { 674 error = ext2_extattr_block_clone(ip, &bp); 675 if (error) { 676 brelse(bp); 677 return (error); 678 } 679 } 680 681 /* If I am last entry, clean me and free the block */ 682 entry = EXT2_FIRST_ENTRY(bp); 683 if (EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry)) && 684 (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) == 685 attrnamespace)) { 686 687 name_len = entry->e_name_len; 688 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 689 entry->e_name, &name_len); 690 if (!attr_name) { 691 brelse(bp); 692 return (ENOTSUP); 693 } 694 695 if (strlen(name) == name_len && 696 0 == strncmp(attr_name, name, name_len)) { 697 ip->i_blocks -= btodb(fs->e2fs_bsize); 698 ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize); 699 ip->i_facl = 0; 700 error = ext2_update(ip->i_vnode, 1); 701 702 brelse(bp); 703 return (error); 704 } 705 } 706 707 for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); 708 entry = EXT2_EXTATTR_NEXT(entry)) { 709 if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) != 710 attrnamespace) 711 continue; 712 713 name_len = entry->e_name_len; 714 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 715 entry->e_name, &name_len); 716 if (!attr_name) { 717 brelse(bp); 718 return (ENOTSUP); 719 } 720 721 if (strlen(name) == name_len && 722 0 == strncmp(attr_name, name, name_len)) { 723 ext2_extattr_delete_entry(bp->b_data, 724 EXT2_FIRST_ENTRY(bp), entry, 725 bp->b_data + bp->b_bufsize); 726 727 return (bwrite(bp)); 728 } 729 } 730 731 brelse(bp); 732 733 return (ENOATTR); 734 } 735 736 static struct ext2fs_extattr_entry * 737 allocate_entry(const char *name, int attrnamespace, uint16_t offs, 738 uint32_t size, uint32_t hash) 739 { 740 const char *attr_name; 741 int name_len; 742 struct ext2fs_extattr_entry *entry; 743 744 attr_name = ext2_extattr_name_to_linux(attrnamespace, name); 745 name_len = strlen(attr_name); 746 747 entry = malloc(sizeof(struct ext2fs_extattr_entry) + name_len, 748 M_TEMP, M_WAITOK); 749 750 entry->e_name_len = name_len; 751 entry->e_name_index = ext2_extattr_attrnamespace_to_linux(attrnamespace, name); 752 entry->e_value_offs = offs; 753 entry->e_value_block = 0; 754 entry->e_value_size = size; 755 entry->e_hash = hash; 756 memcpy(entry->e_name, name, name_len); 757 758 return (entry); 759 } 760 761 static void 762 free_entry(struct ext2fs_extattr_entry *entry) 763 { 764 765 free(entry, M_TEMP); 766 } 767 768 static int 769 ext2_extattr_get_size(struct ext2fs_extattr_entry *first_entry, 770 struct ext2fs_extattr_entry *exist_entry, int header_size, 771 int name_len, int new_size) 772 { 773 struct ext2fs_extattr_entry *entry; 774 int size; 775 776 size = header_size; 777 size += sizeof(uint32_t); 778 779 if (NULL == exist_entry) { 780 size += EXT2_EXTATTR_LEN(name_len); 781 size += EXT2_EXTATTR_SIZE(new_size); 782 } 783 784 if (first_entry) 785 for (entry = first_entry; !EXT2_IS_LAST_ENTRY(entry); 786 entry = EXT2_EXTATTR_NEXT(entry)) { 787 if (entry != exist_entry) 788 size += EXT2_EXTATTR_LEN(entry->e_name_len) + 789 EXT2_EXTATTR_SIZE(entry->e_value_size); 790 else 791 size += EXT2_EXTATTR_LEN(entry->e_name_len) + 792 EXT2_EXTATTR_SIZE(new_size); 793 } 794 795 return (size); 796 } 797 798 static void 799 ext2_extattr_set_exist_entry(char *off, 800 struct ext2fs_extattr_entry *first_entry, 801 struct ext2fs_extattr_entry *entry, 802 char *end, struct uio *uio) 803 { 804 uint16_t min_offs; 805 806 min_offs = ext2_extattr_delete_value(off, first_entry, entry, end); 807 808 entry->e_value_size = uio->uio_resid; 809 if (entry->e_value_size) 810 entry->e_value_offs = min_offs - 811 EXT2_EXTATTR_SIZE(uio->uio_resid); 812 else 813 entry->e_value_offs = 0; 814 815 uiomove(off + entry->e_value_offs, entry->e_value_size, uio); 816 } 817 818 static struct ext2fs_extattr_entry * 819 ext2_extattr_set_new_entry(char *off, struct ext2fs_extattr_entry *first_entry, 820 const char *name, int attrnamespace, char *end, struct uio *uio) 821 { 822 int name_len; 823 char *pad; 824 uint16_t min_offs; 825 struct ext2fs_extattr_entry *entry; 826 struct ext2fs_extattr_entry *new_entry; 827 828 /* Find pad's */ 829 min_offs = end - off; 830 entry = first_entry; 831 while (!EXT2_IS_LAST_ENTRY(entry)) { 832 if (min_offs > entry->e_value_offs && entry->e_value_offs > 0) 833 min_offs = entry->e_value_offs; 834 835 entry = EXT2_EXTATTR_NEXT(entry); 836 } 837 838 pad = (char*)entry + sizeof(uint32_t); 839 840 /* Find entry insert position */ 841 name_len = strlen(name); 842 entry = first_entry; 843 while (!EXT2_IS_LAST_ENTRY(entry)) { 844 if (!(attrnamespace - entry->e_name_index) && 845 !(name_len - entry->e_name_len)) 846 if (memcmp(name, entry->e_name, name_len) <= 0) 847 break; 848 849 entry = EXT2_EXTATTR_NEXT(entry); 850 } 851 852 /* Create new entry and insert it */ 853 new_entry = allocate_entry(name, attrnamespace, 0, uio->uio_resid, 0); 854 memmove((char *)entry + EXT2_EXTATTR_LEN(new_entry->e_name_len), entry, 855 pad - (char*)entry); 856 857 memcpy(entry, new_entry, EXT2_EXTATTR_LEN(new_entry->e_name_len)); 858 free_entry(new_entry); 859 860 new_entry = entry; 861 if (new_entry->e_value_size > 0) 862 new_entry->e_value_offs = min_offs - 863 EXT2_EXTATTR_SIZE(new_entry->e_value_size); 864 865 uiomove(off + new_entry->e_value_offs, new_entry->e_value_size, uio); 866 867 return (new_entry); 868 } 869 870 int 871 ext2_extattr_inode_set(struct inode *ip, int attrnamespace, 872 const char *name, struct uio *uio) 873 { 874 struct m_ext2fs *fs; 875 struct buf *bp; 876 struct ext2fs_extattr_dinode_header *header; 877 struct ext2fs_extattr_entry *entry; 878 const char *attr_name; 879 int name_len; 880 size_t size = 0, max_size; 881 int error; 882 883 fs = ip->i_e2fs; 884 885 if ((error = bread(ip->i_devvp, 886 fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), 887 (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) { 888 brelse(bp); 889 return (error); 890 } 891 892 struct ext2fs_dinode *dinode = (struct ext2fs_dinode *) 893 ((char *)bp->b_data + 894 EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)); 895 896 /* Check attributes magic value */ 897 header = (struct ext2fs_extattr_dinode_header *)((char *)dinode + 898 E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize); 899 900 if (header->h_magic != EXTATTR_MAGIC) { 901 brelse(bp); 902 return (ENOSPC); 903 } 904 905 error = ext2_extattr_check(EXT2_IFIRST(header), (char *)dinode + 906 EXT2_INODE_SIZE(fs)); 907 if (error) { 908 brelse(bp); 909 return (error); 910 } 911 912 /* Find if entry exist */ 913 for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry); 914 entry = EXT2_EXTATTR_NEXT(entry)) { 915 if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) != 916 attrnamespace) 917 continue; 918 919 name_len = entry->e_name_len; 920 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 921 entry->e_name, &name_len); 922 if (!attr_name) { 923 brelse(bp); 924 return (ENOTSUP); 925 } 926 927 if (strlen(name) == name_len && 928 0 == strncmp(attr_name, name, name_len)) 929 break; 930 } 931 932 max_size = EXT2_INODE_SIZE(fs) - E2FS_REV0_INODE_SIZE - 933 dinode->e2di_extra_isize; 934 935 if (!EXT2_IS_LAST_ENTRY(entry)) { 936 size = ext2_extattr_get_size(EXT2_IFIRST(header), entry, 937 sizeof(struct ext2fs_extattr_dinode_header), 938 entry->e_name_len, uio->uio_resid); 939 if (size > max_size) { 940 brelse(bp); 941 return (ENOSPC); 942 } 943 944 ext2_extattr_set_exist_entry((char *)EXT2_IFIRST(header), 945 EXT2_IFIRST(header), entry, (char *)header + max_size, uio); 946 } else { 947 /* Ensure that the same entry does not exist in the block */ 948 if (ip->i_facl) { 949 error = ext2_extattr_block_get(ip, attrnamespace, name, 950 NULL, &size); 951 if (error != ENOATTR || size > 0) { 952 brelse(bp); 953 if (size > 0) 954 error = ENOSPC; 955 956 return (error); 957 } 958 } 959 960 size = ext2_extattr_get_size(EXT2_IFIRST(header), NULL, 961 sizeof(struct ext2fs_extattr_dinode_header), 962 entry->e_name_len, uio->uio_resid); 963 if (size > max_size) { 964 brelse(bp); 965 return (ENOSPC); 966 } 967 968 ext2_extattr_set_new_entry((char *)EXT2_IFIRST(header), 969 EXT2_IFIRST(header), name, attrnamespace, 970 (char *)header + max_size, uio); 971 } 972 973 return (bwrite(bp)); 974 } 975 976 static void 977 ext2_extattr_hash_entry(struct ext2fs_extattr_header *header, 978 struct ext2fs_extattr_entry *entry) 979 { 980 uint32_t hash = 0; 981 char *name = entry->e_name; 982 int n; 983 984 for (n=0; n < entry->e_name_len; n++) { 985 hash = (hash << EXT2_EXTATTR_NAME_HASH_SHIFT) ^ 986 (hash >> (8*sizeof(hash) - EXT2_EXTATTR_NAME_HASH_SHIFT)) ^ 987 (*name++); 988 } 989 990 if (entry->e_value_block == 0 && entry->e_value_size != 0) { 991 uint32_t *value = (uint32_t *)((char *)header + entry->e_value_offs); 992 for (n = (entry->e_value_size + 993 EXT2_EXTATTR_ROUND) >> EXT2_EXTATTR_PAD_BITS; n; n--) { 994 hash = (hash << EXT2_EXTATTR_VALUE_HASH_SHIFT) ^ 995 (hash >> (8*sizeof(hash) - EXT2_EXTATTR_VALUE_HASH_SHIFT)) ^ 996 (*value++); 997 } 998 } 999 1000 entry->e_hash = hash; 1001 } 1002 1003 static void 1004 ext2_extattr_rehash(struct ext2fs_extattr_header *header, 1005 struct ext2fs_extattr_entry *entry) 1006 { 1007 struct ext2fs_extattr_entry *here; 1008 uint32_t hash = 0; 1009 1010 ext2_extattr_hash_entry(header, entry); 1011 1012 here = EXT2_ENTRY(header+1); 1013 while (!EXT2_IS_LAST_ENTRY(here)) { 1014 if (!here->e_hash) { 1015 /* Block is not shared if an entry's hash value == 0 */ 1016 hash = 0; 1017 break; 1018 } 1019 1020 hash = (hash << EXT2_EXTATTR_BLOCK_HASH_SHIFT) ^ 1021 (hash >> (8*sizeof(hash) - EXT2_EXTATTR_BLOCK_HASH_SHIFT)) ^ 1022 here->e_hash; 1023 1024 here = EXT2_EXTATTR_NEXT(here); 1025 } 1026 1027 header->h_hash = hash; 1028 } 1029 1030 int 1031 ext2_extattr_block_set(struct inode *ip, int attrnamespace, 1032 const char *name, struct uio *uio) 1033 { 1034 struct m_ext2fs *fs; 1035 struct buf *bp; 1036 struct ext2fs_extattr_header *header; 1037 struct ext2fs_extattr_entry *entry; 1038 const char *attr_name; 1039 int name_len; 1040 size_t size; 1041 int error; 1042 1043 fs = ip->i_e2fs; 1044 1045 if (ip->i_facl) { 1046 error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl), 1047 fs->e2fs_bsize, NOCRED, &bp); 1048 if (error) { 1049 brelse(bp); 1050 return (error); 1051 } 1052 1053 /* Check attributes magic value */ 1054 header = EXT2_HDR(bp); 1055 if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) { 1056 brelse(bp); 1057 return (EINVAL); 1058 } 1059 1060 error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), 1061 bp->b_data + bp->b_bufsize); 1062 if (error) { 1063 brelse(bp); 1064 return (error); 1065 } 1066 1067 if (header->h_refcount > 1) { 1068 error = ext2_extattr_block_clone(ip, &bp); 1069 if (error) { 1070 brelse(bp); 1071 return (error); 1072 } 1073 1074 header = EXT2_HDR(bp); 1075 } 1076 1077 /* Find if entry exist */ 1078 for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry); 1079 entry = EXT2_EXTATTR_NEXT(entry)) { 1080 if (ext2_extattr_attrnamespace_to_bsd(entry->e_name_index) != 1081 attrnamespace) 1082 continue; 1083 1084 name_len = entry->e_name_len; 1085 attr_name = ext2_extattr_name_to_bsd(entry->e_name_index, 1086 entry->e_name, &name_len); 1087 if (!attr_name) { 1088 brelse(bp); 1089 return (ENOTSUP); 1090 } 1091 1092 if (strlen(name) == name_len && 1093 0 == strncmp(attr_name, name, name_len)) 1094 break; 1095 } 1096 1097 if (!EXT2_IS_LAST_ENTRY(entry)) { 1098 size = ext2_extattr_get_size(EXT2_FIRST_ENTRY(bp), entry, 1099 sizeof(struct ext2fs_extattr_header), 1100 entry->e_name_len, uio->uio_resid); 1101 if (size > bp->b_bufsize) { 1102 brelse(bp); 1103 return (ENOSPC); 1104 } 1105 1106 ext2_extattr_set_exist_entry(bp->b_data, EXT2_FIRST_ENTRY(bp), 1107 entry, bp->b_data + bp->b_bufsize, uio); 1108 } else { 1109 size = ext2_extattr_get_size(EXT2_FIRST_ENTRY(bp), NULL, 1110 sizeof(struct ext2fs_extattr_header), 1111 strlen(name), uio->uio_resid); 1112 if (size > bp->b_bufsize) { 1113 brelse(bp); 1114 return (ENOSPC); 1115 } 1116 1117 entry = ext2_extattr_set_new_entry(bp->b_data, EXT2_FIRST_ENTRY(bp), 1118 name, attrnamespace, bp->b_data + bp->b_bufsize, uio); 1119 1120 /* Clean the same entry in the inode */ 1121 error = ext2_extattr_inode_delete(ip, attrnamespace, name); 1122 if (error && error != ENOATTR) { 1123 brelse(bp); 1124 return (error); 1125 } 1126 } 1127 1128 ext2_extattr_rehash(header, entry); 1129 1130 return (bwrite(bp)); 1131 } 1132 1133 size = ext2_extattr_get_size(NULL, NULL, 1134 sizeof(struct ext2fs_extattr_header), 1135 strlen(ext2_extattr_name_to_linux(attrnamespace, name)), uio->uio_resid); 1136 if (size > fs->e2fs_bsize) 1137 return (ENOSPC); 1138 1139 /* Allocate block, fill EA header and insert entry */ 1140 ip->i_facl = ext2_allocfacl(ip); 1141 if (0 == ip->i_facl) 1142 return (ENOSPC); 1143 1144 ip->i_blocks += btodb(fs->e2fs_bsize); 1145 ext2_update(ip->i_vnode, 1); 1146 1147 bp = getblk(ip->i_devvp, fsbtodb(fs, ip->i_facl), fs->e2fs_bsize, 0, 0, 0); 1148 if (!bp) { 1149 ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize); 1150 ip->i_blocks -= btodb(fs->e2fs_bsize); 1151 ip->i_facl = 0; 1152 ext2_update(ip->i_vnode, 1); 1153 return (EIO); 1154 } 1155 1156 header = EXT2_HDR(bp); 1157 header->h_magic = EXTATTR_MAGIC; 1158 header->h_refcount = 1; 1159 header->h_blocks = 1; 1160 header->h_hash = 0; 1161 memset(header->h_reserved, 0, sizeof(header->h_reserved)); 1162 memcpy(bp->b_data, header, sizeof(struct ext2fs_extattr_header)); 1163 memset(EXT2_FIRST_ENTRY(bp), 0, sizeof(uint32_t)); 1164 1165 entry = ext2_extattr_set_new_entry(bp->b_data, EXT2_FIRST_ENTRY(bp), 1166 name, attrnamespace, bp->b_data + bp->b_bufsize, uio); 1167 1168 /* Clean the same entry in the inode */ 1169 error = ext2_extattr_inode_delete(ip, attrnamespace, name); 1170 if (error && error != ENOATTR) { 1171 brelse(bp); 1172 return (error); 1173 } 1174 1175 ext2_extattr_rehash(header, entry); 1176 1177 return (bwrite(bp)); 1178 } 1179 1180 int ext2_extattr_free(struct inode *ip) 1181 { 1182 struct m_ext2fs *fs; 1183 struct buf *bp; 1184 struct ext2fs_extattr_header *header; 1185 int error; 1186 1187 fs = ip->i_e2fs; 1188 1189 if (!ip->i_facl) 1190 return (0); 1191 1192 error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl), 1193 fs->e2fs_bsize, NOCRED, &bp); 1194 if (error) { 1195 brelse(bp); 1196 return (error); 1197 } 1198 1199 /* Check attributes magic value */ 1200 header = EXT2_HDR(bp); 1201 if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) { 1202 brelse(bp); 1203 return (EINVAL); 1204 } 1205 1206 error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize); 1207 if (error) { 1208 brelse(bp); 1209 return (error); 1210 } 1211 1212 if (header->h_refcount > 1) { 1213 header->h_refcount--; 1214 bwrite(bp); 1215 } else { 1216 ext2_blkfree(ip, ip->i_facl, ip->i_e2fs->e2fs_bsize); 1217 brelse(bp); 1218 } 1219 1220 ip->i_blocks -= btodb(ip->i_e2fs->e2fs_bsize); 1221 ip->i_facl = 0; 1222 ext2_update(ip->i_vnode, 1); 1223 1224 return (0); 1225 } 1226