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