diff --git a/sys/fs/ext2fs/ext2_alloc.c b/sys/fs/ext2fs/ext2_alloc.c
index 46f160846981..55c1471201b5 100644
--- a/sys/fs/ext2fs/ext2_alloc.c
+++ b/sys/fs/ext2fs/ext2_alloc.c
@@ -131,6 +131,25 @@ ext2_alloc(struct inode *ip, daddr_t lbn, e4fs_daddr_t bpref, int size,
 	return (ENOSPC);
 }
 
+/*
+ * Allocate EA's block for inode.
+ */
+daddr_t
+ext2_allocfacl(struct inode *ip)
+{
+	struct m_ext2fs *fs;
+	daddr_t facl;
+
+	fs = ip->i_e2fs;
+
+	EXT2_LOCK(ip->i_ump);
+	facl = ext2_alloccg(ip, ino_to_cg(fs, ip->i_number), 0, fs->e2fs_bsize);
+	if (0 == facl)
+		EXT2_UNLOCK(ip->i_ump);
+
+	return (facl);
+}
+
 /*
  * Reallocate a sequence of blocks into a contiguous sequence of blocks.
  *
diff --git a/sys/fs/ext2fs/ext2_extattr.c b/sys/fs/ext2fs/ext2_extattr.c
index 27f4405722a1..28ba8f9ad1a9 100644
--- a/sys/fs/ext2fs/ext2_extattr.c
+++ b/sys/fs/ext2fs/ext2_extattr.c
@@ -44,21 +44,66 @@
 #include <fs/ext2fs/ext2_dinode.h>
 #include <fs/ext2fs/ext2_mount.h>
 #include <fs/ext2fs/ext2_extattr.h>
+#include <fs/ext2fs/ext2_extern.h>
 
 
 static int
 ext2_extattr_index_to_bsd(int index)
 {
 	switch (index) {
-		case EXT4_XATTR_INDEX_USER:
-			return EXTATTR_NAMESPACE_USER;
-
 		case EXT4_XATTR_INDEX_SYSTEM:
-			return EXTATTR_NAMESPACE_SYSTEM;
+			return (EXTATTR_NAMESPACE_SYSTEM);
 
-		default:
-			return EXTATTR_NAMESPACE_EMPTY;
+		case EXT4_XATTR_INDEX_USER:
+			return (EXTATTR_NAMESPACE_USER);
 	}
+
+	return (EXTATTR_NAMESPACE_EMPTY);
+}
+
+static int
+ext2_extattr_index_to_linux(int index)
+{
+	switch (index) {
+		case EXTATTR_NAMESPACE_SYSTEM:
+			return (EXT4_XATTR_INDEX_SYSTEM);
+
+		case EXTATTR_NAMESPACE_USER:
+			return (EXT4_XATTR_INDEX_USER);
+	}
+
+	return (-1);
+}
+
+int
+ext2_extattr_valid_attrname(int attrnamespace, const char *attrname)
+{
+	if (attrnamespace == EXTATTR_NAMESPACE_EMPTY)
+		return (EINVAL);
+
+	if (strlen(attrname) == 0)
+		return (EINVAL);
+
+	if (strlen(attrname) + 1 > EXT2_EXTATTR_NAMELEN_MAX)
+		return (ENAMETOOLONG);
+
+	return (0);
+}
+
+static int
+ext2_extattr_check(struct ext2fs_extattr_entry *entry, char *end)
+{
+	struct ext2fs_extattr_entry *next;
+
+	while (!EXT2_IS_LAST_ENTRY(entry)) {
+		next = EXT2_EXTATTR_NEXT(entry);
+		if ((char *)next >= end)
+			return (EIO);
+
+		entry = next;
+	}
+
+	return (0);
 }
 
 int
@@ -69,8 +114,6 @@ ext2_extattr_inode_list(struct inode *ip, int attrnamespace,
 	struct buf *bp;
 	struct ext2fs_extattr_dinode_header *header;
 	struct ext2fs_extattr_entry *entry;
-	struct ext2fs_extattr_entry *next;
-	char *end;
 	int error;
 
 	fs = ip->i_e2fs;
@@ -95,21 +138,15 @@ ext2_extattr_inode_list(struct inode *ip, int attrnamespace,
 		return (0);
 	}
 
-	/* Check attributes integrity */
-	entry = EXT2_IFIRST(header);
-	end = (char *)dinode + EXT2_INODE_SIZE(fs);
-	while (!EXT2_IS_LAST_ENTRY(entry)) {
-		next = EXT2_EXTATTR_NEXT(entry);
-		if ((char *)next >= end) {
-			brelse(bp);
-			return (EIO);
-		}
-
-		entry = next;
+	error = ext2_extattr_check(EXT2_IFIRST(header),
+	    (char *)dinode + EXT2_INODE_SIZE(fs));
+	if (error) {
+		brelse(bp);
+		return (error);
 	}
 
 	for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry);
-		entry = EXT2_EXTATTR_NEXT(entry)) {
+	    entry = EXT2_EXTATTR_NEXT(entry)) {
 		if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace)
 			continue;
 
@@ -121,12 +158,14 @@ ext2_extattr_inode_list(struct inode *ip, int attrnamespace,
 			memcpy(&attr_name[1], entry->e_name, entry->e_name_len);
 			error = uiomove(attr_name, entry->e_name_len + 1, uio);
 			free(attr_name, M_TEMP);
+			if (error)
+				break;
 		}
 	}
 
 	brelse(bp);
 
-	return (0);
+	return (error);
 }
 
 int
@@ -137,8 +176,6 @@ ext2_extattr_block_list(struct inode *ip, int attrnamespace,
 	struct buf *bp;
 	struct ext2fs_extattr_header *header;
 	struct ext2fs_extattr_entry *entry;
-	struct ext2fs_extattr_entry *next;
-	char *end;
 	int error;
 
 	fs = ip->i_e2fs;
@@ -157,17 +194,10 @@ ext2_extattr_block_list(struct inode *ip, int attrnamespace,
 		return (EINVAL);
 	}
 
-	/* Check attributes integrity */
-	end = bp->b_data + bp->b_bufsize;
-	entry = EXT2_FIRST_ENTRY(bp);
-	while (!EXT2_IS_LAST_ENTRY(entry)) {
-		next = EXT2_EXTATTR_NEXT(entry);
-		if ((char *)next >= end) {
-			brelse(bp);
-			return (EIO);
-		}
-
-		entry = next;
+	error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize);
+	if (error) {
+		brelse(bp);
+		return (error);
 	}
 
 	for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry);
@@ -183,12 +213,14 @@ ext2_extattr_block_list(struct inode *ip, int attrnamespace,
 			memcpy(&attr_name[1], entry->e_name, entry->e_name_len);
 			error = uiomove(attr_name, entry->e_name_len + 1, uio);
 			free(attr_name, M_TEMP);
+			if (error)
+				break;
 		}
 	}
 
 	brelse(bp);
 
-	return (0);
+	return (error);
 }
 
 int
@@ -199,8 +231,6 @@ ext2_extattr_inode_get(struct inode *ip, int attrnamespace,
 	struct buf *bp;
 	struct ext2fs_extattr_dinode_header *header;
 	struct ext2fs_extattr_entry *entry;
-	struct ext2fs_extattr_entry *next;
-	char *end;
 	int error;
 
 	fs = ip->i_e2fs;
@@ -222,20 +252,14 @@ ext2_extattr_inode_get(struct inode *ip, int attrnamespace,
 
 	if (header->h_magic != EXTATTR_MAGIC) {
 		brelse(bp);
-		return (0);
+		return (ENOATTR);
 	}
 
-	/* Check attributes integrity */
-	entry = EXT2_IFIRST(header);
-	end = (char *)dinode + EXT2_INODE_SIZE(fs);
-	while (!EXT2_IS_LAST_ENTRY(entry)) {
-		next = EXT2_EXTATTR_NEXT(entry);
-		if ((char *)next >= end) {
-			brelse(bp);
-			return (EIO);
-		}
-
-		entry = next;
+	error = ext2_extattr_check(EXT2_IFIRST(header),
+	    (char *)dinode + EXT2_INODE_SIZE(fs));
+	if (error) {
+		brelse(bp);
+		return (error);
 	}
 
 	for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry);
@@ -248,19 +272,18 @@ ext2_extattr_inode_get(struct inode *ip, int attrnamespace,
 			if (uio == NULL)
 				*size += entry->e_value_size;
 			else {
-				error = uiomove(((char *)EXT2_IFIRST(header)) + entry->e_value_offs,
-				    entry->e_value_size, uio);
-				if (error) {
-					brelse(bp);
-					return (error);
-				}
+				error = uiomove(((char *)EXT2_IFIRST(header)) +
+				    entry->e_value_offs, entry->e_value_size, uio);
 			}
+
+			brelse(bp);
+			return (error);
 		}
 	 }
 
 	brelse(bp);
 
-	return (0);
+	return (ENOATTR);
 }
 
 int
@@ -271,8 +294,6 @@ ext2_extattr_block_get(struct inode *ip, int attrnamespace,
 	struct buf *bp;
 	struct ext2fs_extattr_header *header;
 	struct ext2fs_extattr_entry *entry;
-	struct ext2fs_extattr_entry *next;
-	char *end;
 	int error;
 
 	fs = ip->i_e2fs;
@@ -291,17 +312,10 @@ ext2_extattr_block_get(struct inode *ip, int attrnamespace,
 		return (EINVAL);
 	}
 
-	/* Check attributes integrity */
-	end = bp->b_data + bp->b_bufsize;
-	entry = EXT2_FIRST_ENTRY(bp);
-	while (!EXT2_IS_LAST_ENTRY(entry)) {
-		next = EXT2_EXTATTR_NEXT(entry);
-		if ((char *)next >= end) {
-			brelse(bp);
-			return (EIO);
-		}
-
-		entry = next;
+	error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize);
+	if (error) {
+		brelse(bp);
+		return (error);
 	}
 
 	for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry);
@@ -316,15 +330,725 @@ ext2_extattr_block_get(struct inode *ip, int attrnamespace,
 			else {
 				error = uiomove(bp->b_data + entry->e_value_offs,
 				    entry->e_value_size, uio);
-				if (error) {
-					brelse(bp);
-					return (error);
-				}
 			}
+
+			brelse(bp);
+			return (error);
 		}
 	 }
 
 	brelse(bp);
 
+	return (ENOATTR);
+}
+
+static uint16_t
+ext2_extattr_delete_value(char *off,
+    struct ext2fs_extattr_entry *first_entry,
+    struct ext2fs_extattr_entry *entry, char *end)
+{
+	uint16_t min_offs;
+	struct ext2fs_extattr_entry *next;
+
+	min_offs = end - off;
+	next = first_entry;
+	while (!EXT2_IS_LAST_ENTRY(next)) {
+		if (min_offs > next->e_value_offs && next->e_value_offs > 0)
+			min_offs = next->e_value_offs;
+
+		next = EXT2_EXTATTR_NEXT(next);
+	}
+
+	if (entry->e_value_size == 0)
+		return (min_offs);
+
+	memmove(off + min_offs + EXT2_EXTATTR_SIZE(entry->e_value_size),
+	    off + min_offs, entry->e_value_offs - min_offs);
+
+	/* Adjust all value offsets */
+	next = first_entry;
+	while (!EXT2_IS_LAST_ENTRY(next))
+	{
+		if (next->e_value_offs > 0 &&
+		    next->e_value_offs < entry->e_value_offs)
+			next->e_value_offs +=
+			    EXT2_EXTATTR_SIZE(entry->e_value_size);
+
+		next = EXT2_EXTATTR_NEXT(next);
+	}
+
+	min_offs += EXT2_EXTATTR_SIZE(entry->e_value_size);
+
+	return (min_offs);
+}
+
+static void
+ext2_extattr_delete_entry(char *off,
+    struct ext2fs_extattr_entry *first_entry,
+    struct ext2fs_extattr_entry *entry, char *end)
+{
+	char *pad;
+	struct ext2fs_extattr_entry *next;
+
+	/* Clean entry value */
+	ext2_extattr_delete_value(off, first_entry, entry, end);
+
+	/* Clean the entry */
+	next = first_entry;
+	while (!EXT2_IS_LAST_ENTRY(next))
+		next = EXT2_EXTATTR_NEXT(next);
+
+	pad = (char*)next + sizeof(uint32_t);
+
+	memmove(entry, (char *)entry + EXT2_EXTATTR_LEN(entry->e_name_len),
+	    pad - ((char *)entry + EXT2_EXTATTR_LEN(entry->e_name_len)));
+}
+
+int
+ext2_extattr_inode_delete(struct inode *ip, int attrnamespace, const char *name)
+{
+	struct m_ext2fs *fs;
+	struct buf *bp;
+	struct ext2fs_extattr_dinode_header *header;
+	struct ext2fs_extattr_entry *entry;
+	int error;
+
+	fs = ip->i_e2fs;
+
+	if ((error = bread(ip->i_devvp,
+	    fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
+	    (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
+		brelse(bp);
+		return (error);
+	}
+
+	struct ext2fs_dinode *dinode = (struct ext2fs_dinode *)
+	    ((char *)bp->b_data +
+	    EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number));
+
+	/* Check attributes magic value */
+	header = (struct ext2fs_extattr_dinode_header *)((char *)dinode +
+	    E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize);
+
+	if (header->h_magic != EXTATTR_MAGIC) {
+		brelse(bp);
+		return (ENOATTR);
+	}
+
+	error = ext2_extattr_check(EXT2_IFIRST(header),
+	    (char *)dinode + EXT2_INODE_SIZE(fs));
+	if (error) {
+		brelse(bp);
+		return (error);
+	}
+
+	/* If I am last entry, just make magic zero */
+	entry = EXT2_IFIRST(header);
+	if (EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry))) {
+		if (strlen(name) == entry->e_name_len &&
+		    0 == strncmp(entry->e_name, name, entry->e_name_len)) {
+			memset(header, 0, sizeof(struct ext2fs_extattr_dinode_header));
+
+			return (bwrite(bp));
+		}
+	}
+
+	for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry);
+	    entry = EXT2_EXTATTR_NEXT(entry)) {
+		if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace)
+			continue;
+
+		if (strlen(name) == entry->e_name_len &&
+		    0 == strncmp(entry->e_name, name, entry->e_name_len)) {
+			ext2_extattr_delete_entry((char *)EXT2_IFIRST(header),
+			    EXT2_IFIRST(header), entry,
+			    (char *)dinode + EXT2_INODE_SIZE(fs));
+
+			return (bwrite(bp));
+		}
+	}
+
+	brelse(bp);
+
+	return (ENOATTR);
+}
+
+static int
+ext2_extattr_block_clone(struct inode *ip, struct buf **bpp)
+{
+	struct m_ext2fs *fs;
+	struct buf *sbp;
+	struct buf *cbp;
+	struct ext2fs_extattr_header *header;
+	uint64_t facl;
+
+	fs = ip->i_e2fs;
+	sbp = *bpp;
+
+	header = EXT2_HDR(sbp);
+	if (header->h_magic != EXTATTR_MAGIC || header->h_refcount == 1)
+		return (EINVAL);
+
+	facl = ext2_allocfacl(ip);
+	if (!facl)
+		return (ENOSPC);
+
+	cbp = getblk(ip->i_devvp, fsbtodb(fs, facl), fs->e2fs_bsize, 0, 0, 0);
+	if (!cbp) {
+		ext2_blkfree(ip, facl, fs->e2fs_bsize);
+		return (EIO);
+	}
+
+	memcpy(cbp->b_data, sbp->b_data, fs->e2fs_bsize);
+	header->h_refcount--;
+	bwrite(sbp);
+
+	ip->i_facl = facl;
+	ext2_update(ip->i_vnode, 1);
+
+	header = EXT2_HDR(cbp);
+	header->h_refcount = 1;
+
+	*bpp = cbp;
+
+	return (0);
+}
+
+int
+ext2_extattr_block_delete(struct inode *ip, int attrnamespace, const char *name)
+{
+	struct m_ext2fs *fs;
+	struct buf *bp;
+	struct ext2fs_extattr_header *header;
+	struct ext2fs_extattr_entry *entry;
+	int error;
+
+	fs = ip->i_e2fs;
+
+	error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl),
+	    fs->e2fs_bsize, NOCRED, &bp);
+	if (error) {
+		brelse(bp);
+		return (error);
+	}
+
+	/* Check attributes magic value */
+	header = EXT2_HDR(bp);
+	if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) {
+		brelse(bp);
+		return (EINVAL);
+	}
+
+	error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize);
+	if (error) {
+		brelse(bp);
+		return (error);
+	}
+
+	if (header->h_refcount > 1) {
+		error = ext2_extattr_block_clone(ip, &bp);
+		if (error) {
+			brelse(bp);
+			return (error);
+		}
+	}
+
+	/* If I am last entry, clean me and free the block */
+	entry = EXT2_FIRST_ENTRY(bp);
+	if (EXT2_IS_LAST_ENTRY(EXT2_EXTATTR_NEXT(entry))) {
+		if (strlen(name) == entry->e_name_len &&
+		    0 == strncmp(entry->e_name, name, entry->e_name_len)) {
+			ip->i_blocks -= btodb(fs->e2fs_bsize);
+			ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize);
+			ip->i_facl = 0;
+			error = ext2_update(ip->i_vnode, 1);
+
+			brelse(bp);
+			return (error);
+		}
+	}
+
+	for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry);
+	    entry = EXT2_EXTATTR_NEXT(entry)) {
+		if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace)
+			continue;
+
+		if (strlen(name) == entry->e_name_len &&
+		    0 == strncmp(entry->e_name, name, entry->e_name_len)) {
+			ext2_extattr_delete_entry(bp->b_data,
+			    EXT2_FIRST_ENTRY(bp), entry,
+			    bp->b_data + bp->b_bufsize);
+
+			return (bwrite(bp));
+		}
+	}
+
+	brelse(bp);
+
+	return (ENOATTR);
+}
+
+static struct ext2fs_extattr_entry *
+allocate_entry(const char *name, int attrnamespace, uint16_t offs,
+    uint32_t size, uint32_t hash)
+{
+	size_t name_len;
+	struct ext2fs_extattr_entry *entry;
+
+	name_len = strlen(name);
+	entry = malloc(sizeof(struct ext2fs_extattr_entry) + name_len,
+	    M_TEMP, M_WAITOK);
+
+	entry->e_name_len = name_len;
+	entry->e_name_index = ext2_extattr_index_to_linux(attrnamespace);
+	entry->e_value_offs = offs;
+	entry->e_value_block = 0;
+	entry->e_value_size = size;
+	entry->e_hash = hash;
+	memcpy(entry->e_name, name, name_len);
+
+	return (entry);
+}
+
+static void
+free_entry(struct ext2fs_extattr_entry *entry)
+{
+
+	free(entry, M_TEMP);
+}
+
+static int
+ext2_extattr_get_size(struct ext2fs_extattr_entry *first_entry,
+    struct ext2fs_extattr_entry *exist_entry, int header_size,
+    int name_len, int new_size)
+{
+	struct ext2fs_extattr_entry *entry;
+	int size;
+
+	size = header_size;
+	size += sizeof(uint32_t);
+
+	if (NULL == exist_entry) {
+		size += EXT2_EXTATTR_LEN(name_len);
+		size += EXT2_EXTATTR_SIZE(new_size);
+	}
+
+	if (first_entry)
+		for (entry = first_entry; !EXT2_IS_LAST_ENTRY(entry);
+		    entry = EXT2_EXTATTR_NEXT(entry)) {
+			if (entry != exist_entry)
+				size += EXT2_EXTATTR_LEN(entry->e_name_len) +
+				    EXT2_EXTATTR_SIZE(entry->e_value_size);
+			else
+				size += EXT2_EXTATTR_LEN(entry->e_name_len) +
+				    EXT2_EXTATTR_SIZE(new_size);
+		}
+
+	return (size);
+}
+
+static void
+ext2_extattr_set_exist_entry(char *off,
+    struct ext2fs_extattr_entry *first_entry,
+    struct ext2fs_extattr_entry *entry,
+    char *end, struct uio *uio)
+{
+	uint16_t min_offs;
+
+	min_offs = ext2_extattr_delete_value(off, first_entry, entry, end);
+
+	entry->e_value_size = uio->uio_resid;
+	if (entry->e_value_size)
+		entry->e_value_offs = min_offs -
+		    EXT2_EXTATTR_SIZE(uio->uio_resid);
+	else
+		entry->e_value_offs = 0;
+
+	uiomove(off + entry->e_value_offs, entry->e_value_size, uio);
+}
+
+static struct ext2fs_extattr_entry *
+ext2_extattr_set_new_entry(char *off, struct ext2fs_extattr_entry *first_entry,
+    const char *name, int attrnamespace, char *end, struct uio *uio)
+{
+	int name_len;
+	char *pad;
+	uint16_t min_offs;
+	struct ext2fs_extattr_entry *entry;
+	struct ext2fs_extattr_entry *new_entry;
+
+	/* Find pad's */
+	min_offs = end - off;
+	entry = first_entry;
+	while (!EXT2_IS_LAST_ENTRY(entry)) {
+		if (min_offs > entry->e_value_offs && entry->e_value_offs > 0)
+			min_offs = entry->e_value_offs;
+
+		entry = EXT2_EXTATTR_NEXT(entry);
+	}
+
+	pad = (char*)entry + sizeof(uint32_t);
+
+	/* Find entry insert position */
+	name_len = strlen(name);
+	entry = first_entry;
+	while (!EXT2_IS_LAST_ENTRY(entry)) {
+		if (!(attrnamespace - entry->e_name_index) &&
+		    !(name_len - entry->e_name_len))
+			if (memcmp(name, entry->e_name, name_len) <= 0)
+				break;
+
+		entry = EXT2_EXTATTR_NEXT(entry);
+	}
+
+	/* Create new entry and insert it */
+	new_entry = allocate_entry(name, attrnamespace, 0, uio->uio_resid, 0);
+	memmove((char *)entry + EXT2_EXTATTR_LEN(new_entry->e_name_len), entry,
+	    pad - (char*)entry);
+
+	memcpy(entry, new_entry, EXT2_EXTATTR_LEN(new_entry->e_name_len));
+	free_entry(new_entry);
+
+	new_entry = entry;
+	if (new_entry->e_value_size > 0)
+		new_entry->e_value_offs = min_offs -
+		    EXT2_EXTATTR_SIZE(new_entry->e_value_size);
+
+	uiomove(off + new_entry->e_value_offs, new_entry->e_value_size, uio);
+
+	return (new_entry);
+}
+
+int
+ext2_extattr_inode_set(struct inode *ip, int attrnamespace,
+    const char *name, struct uio *uio)
+{
+	struct m_ext2fs *fs;
+	struct buf *bp;
+	struct ext2fs_extattr_dinode_header *header;
+	struct ext2fs_extattr_entry *entry;
+	size_t size = 0, max_size;
+	int error;
+
+	fs = ip->i_e2fs;
+
+	if ((error = bread(ip->i_devvp,
+	    fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
+	    (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
+		brelse(bp);
+		return (error);
+	}
+
+	struct ext2fs_dinode *dinode = (struct ext2fs_dinode *)
+	    ((char *)bp->b_data +
+	    EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number));
+
+	/* Check attributes magic value */
+	header = (struct ext2fs_extattr_dinode_header *)((char *)dinode +
+	    E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize);
+
+	if (header->h_magic != EXTATTR_MAGIC) {
+		brelse(bp);
+		return (ENOSPC);
+	}
+
+	error = ext2_extattr_check(EXT2_IFIRST(header), (char *)dinode +
+	    EXT2_INODE_SIZE(fs));
+	if (error) {
+		brelse(bp);
+		return (error);
+	}
+
+	/* Find if entry exist */
+	for (entry = EXT2_IFIRST(header); !EXT2_IS_LAST_ENTRY(entry);
+	    entry = EXT2_EXTATTR_NEXT(entry)) {
+		if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace)
+			continue;
+
+		if (strlen(name) == entry->e_name_len &&
+		    0 == strncmp(entry->e_name, name, entry->e_name_len))
+			break;
+	}
+
+	max_size = EXT2_INODE_SIZE(fs) - E2FS_REV0_INODE_SIZE -
+	    dinode->e2di_extra_isize;
+
+	if (!EXT2_IS_LAST_ENTRY(entry)) {
+		size = ext2_extattr_get_size(EXT2_IFIRST(header), entry,
+		    sizeof(struct ext2fs_extattr_dinode_header),
+		    entry->e_name_len, uio->uio_resid);
+		if (size > max_size) {
+			brelse(bp);
+			return (ENOSPC);
+		}
+
+		ext2_extattr_set_exist_entry((char *)EXT2_IFIRST(header),
+		    EXT2_IFIRST(header), entry, (char *)header + max_size, uio);
+	} else {
+		/* Ensure that the same entry does not exist in the block */
+		if (ip->i_facl) {
+			error = ext2_extattr_block_get(ip, attrnamespace, name,
+			    NULL, &size);
+			if (error != ENOATTR || size > 0) {
+				brelse(bp);
+				if (size > 0)
+					error = ENOSPC;
+
+				return (error);
+			}
+		}
+
+		size = ext2_extattr_get_size(EXT2_IFIRST(header), NULL,
+		    sizeof(struct ext2fs_extattr_dinode_header),
+		    entry->e_name_len, uio->uio_resid);
+		if (size > max_size) {
+			brelse(bp);
+			return (ENOSPC);
+		}
+
+		ext2_extattr_set_new_entry((char *)EXT2_IFIRST(header),
+		    EXT2_IFIRST(header), name, attrnamespace,
+		    (char *)header + max_size, uio);
+	}
+
+	return (bwrite(bp));
+}
+
+static void
+ext2_extattr_hash_entry(struct ext2fs_extattr_header *header,
+    struct ext2fs_extattr_entry *entry)
+{
+	uint32_t hash = 0;
+	char *name = entry->e_name;
+	int n;
+
+	for (n=0; n < entry->e_name_len; n++) {
+		hash = (hash << EXT2_EXTATTR_NAME_HASH_SHIFT) ^
+		    (hash >> (8*sizeof(hash) - EXT2_EXTATTR_NAME_HASH_SHIFT)) ^
+		    (*name++);
+	}
+
+	if (entry->e_value_block == 0 && entry->e_value_size != 0) {
+		uint32_t *value = (uint32_t *)((char *)header + entry->e_value_offs);
+		for (n = (entry->e_value_size +
+		    EXT2_EXTATTR_ROUND) >> EXT2_EXTATTR_PAD_BITS; n; n--) {
+			hash = (hash << EXT2_EXTATTR_VALUE_HASH_SHIFT) ^
+			    (hash >> (8*sizeof(hash) - EXT2_EXTATTR_VALUE_HASH_SHIFT)) ^
+			    (*value++);
+		}
+	}
+
+	entry->e_hash = hash;
+}
+
+static void
+ext2_extattr_rehash(struct ext2fs_extattr_header *header,
+    struct ext2fs_extattr_entry *entry)
+{
+	struct ext2fs_extattr_entry *here;
+	uint32_t hash = 0;
+
+	ext2_extattr_hash_entry(header, entry);
+
+	here = EXT2_ENTRY(header+1);
+	while (!EXT2_IS_LAST_ENTRY(here)) {
+		if (!here->e_hash) {
+			/* Block is not shared if an entry's hash value == 0 */
+			hash = 0;
+			break;
+		}
+
+		hash = (hash << EXT2_EXTATTR_BLOCK_HASH_SHIFT) ^
+		    (hash >> (8*sizeof(hash) - EXT2_EXTATTR_BLOCK_HASH_SHIFT)) ^
+		    here->e_hash;
+
+		here = EXT2_EXTATTR_NEXT(here);
+	}
+
+	header->h_hash = hash;
+}
+
+int
+ext2_extattr_block_set(struct inode *ip, int attrnamespace,
+    const char *name, struct uio *uio)
+{
+	struct m_ext2fs *fs;
+	struct buf *bp;
+	struct ext2fs_extattr_header *header;
+	struct ext2fs_extattr_entry *entry;
+	size_t size;
+	int error;
+
+	fs = ip->i_e2fs;
+
+	if (ip->i_facl) {
+		error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl),
+		    fs->e2fs_bsize, NOCRED, &bp);
+		if (error) {
+			brelse(bp);
+			return (error);
+		}
+
+		/* Check attributes magic value */
+		header = EXT2_HDR(bp);
+		if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) {
+			brelse(bp);
+			return (EINVAL);
+		}
+
+		error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp),
+		    bp->b_data + bp->b_bufsize);
+		if (error) {
+			brelse(bp);
+			return (error);
+		}
+
+		if (header->h_refcount > 1) {
+			error = ext2_extattr_block_clone(ip, &bp);
+			if (error) {
+				brelse(bp);
+				return (error);
+			}
+
+			header = EXT2_HDR(bp);
+		}
+
+		/* Find if entry exist */
+		for (entry = EXT2_FIRST_ENTRY(bp); !EXT2_IS_LAST_ENTRY(entry);
+		    entry = EXT2_EXTATTR_NEXT(entry)) {
+			if (ext2_extattr_index_to_bsd(entry->e_name_index) != attrnamespace)
+				continue;
+
+			if (strlen(name) == entry->e_name_len &&
+			    0 == strncmp(entry->e_name, name, entry->e_name_len))
+				break;
+		}
+
+		if (!EXT2_IS_LAST_ENTRY(entry)) {
+			size = ext2_extattr_get_size(EXT2_FIRST_ENTRY(bp), entry,
+			    sizeof(struct ext2fs_extattr_header),
+			    entry->e_name_len, uio->uio_resid);
+			if (size > bp->b_bufsize) {
+				brelse(bp);
+				return (ENOSPC);
+			}
+
+			ext2_extattr_set_exist_entry(bp->b_data, EXT2_FIRST_ENTRY(bp),
+			    entry, bp->b_data + bp->b_bufsize, uio);
+		} else {
+			size = ext2_extattr_get_size(EXT2_FIRST_ENTRY(bp), NULL,
+			    sizeof(struct ext2fs_extattr_header),
+			    strlen(name), uio->uio_resid);
+			if (size > bp->b_bufsize) {
+				brelse(bp);
+				return (ENOSPC);
+			}
+
+			entry = ext2_extattr_set_new_entry(bp->b_data, EXT2_FIRST_ENTRY(bp),
+			    name, attrnamespace, bp->b_data + bp->b_bufsize, uio);
+
+			/* Clean the same entry in the inode */
+			error = ext2_extattr_inode_delete(ip, attrnamespace, name);
+			if (error && error != ENOATTR) {
+				brelse(bp);
+				return (error);
+			}
+		}
+
+		ext2_extattr_rehash(header, entry);
+
+		return (bwrite(bp));
+	}
+
+	size = ext2_extattr_get_size(NULL, NULL,
+	    sizeof(struct ext2fs_extattr_header), strlen(name), uio->uio_resid);
+	if (size > fs->e2fs_bsize)
+		return (ENOSPC);
+
+	/* Allocate block, fill EA header and insert entry */
+	ip->i_facl = ext2_allocfacl(ip);
+	if (0 == ip->i_facl)
+		return (ENOSPC);
+
+	ip->i_blocks += btodb(fs->e2fs_bsize);
+	ext2_update(ip->i_vnode, 1);
+
+	bp = getblk(ip->i_devvp, fsbtodb(fs, ip->i_facl), fs->e2fs_bsize, 0, 0, 0);
+	if (!bp) {
+		ext2_blkfree(ip, ip->i_facl, fs->e2fs_bsize);
+		ip->i_blocks -= btodb(fs->e2fs_bsize);
+		ip->i_facl = 0;
+		ext2_update(ip->i_vnode, 1);
+		return (EIO);
+	}
+
+	header = EXT2_HDR(bp);
+	header->h_magic = EXTATTR_MAGIC;
+	header->h_refcount = 1;
+	header->h_blocks = 1;
+	header->h_hash = 0;
+	memset(header->h_reserved, 0, sizeof(header->h_reserved));
+	memcpy(bp->b_data, header, sizeof(struct ext2fs_extattr_header));
+	memset(EXT2_FIRST_ENTRY(bp), 0, sizeof(uint32_t));
+
+	entry = ext2_extattr_set_new_entry(bp->b_data, EXT2_FIRST_ENTRY(bp),
+	    name, attrnamespace, bp->b_data + bp->b_bufsize, uio);
+
+	/* Clean the same entry in the inode */
+	error = ext2_extattr_inode_delete(ip, attrnamespace, name);
+	if (error && error != ENOATTR) {
+		brelse(bp);
+		return (error);
+	}
+
+	ext2_extattr_rehash(header, entry);
+
+	return (bwrite(bp));
+}
+
+int ext2_extattr_free(struct inode *ip)
+{
+	struct m_ext2fs *fs;
+	struct buf *bp;
+	struct ext2fs_extattr_header *header;
+	int error;
+
+	fs = ip->i_e2fs;
+
+	if (!ip->i_facl)
+		return (0);
+
+	error = bread(ip->i_devvp, fsbtodb(fs, ip->i_facl),
+	    fs->e2fs_bsize, NOCRED, &bp);
+	if (error) {
+		brelse(bp);
+		return (error);
+	}
+
+	/* Check attributes magic value */
+	header = EXT2_HDR(bp);
+	if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) {
+		brelse(bp);
+		return (EINVAL);
+	}
+
+	error = ext2_extattr_check(EXT2_FIRST_ENTRY(bp), bp->b_data + bp->b_bufsize);
+	if (error) {
+		brelse(bp);
+		return (error);
+	}
+
+	if (header->h_refcount > 1) {
+		header->h_refcount--;
+		bwrite(bp);
+	} else {
+		ext2_blkfree(ip, ip->i_facl, ip->i_e2fs->e2fs_bsize);
+		brelse(bp);
+	}
+
+	ip->i_blocks -= btodb(ip->i_e2fs->e2fs_bsize);
+	ip->i_facl = 0;
+	ext2_update(ip->i_vnode, 1);
+
 	return (0);
 }
diff --git a/sys/fs/ext2fs/ext2_extattr.h b/sys/fs/ext2fs/ext2_extattr.h
index 94091ed8ef40..50ab6908a0de 100644
--- a/sys/fs/ext2fs/ext2_extattr.h
+++ b/sys/fs/ext2fs/ext2_extattr.h
@@ -30,25 +30,34 @@
 #define	_FS_EXT2FS_EXT2_EXTARTTR_H_
 
 /* Linux xattr name indexes */
-#define	EXT4_XATTR_INDEX_USER				1
+#define	EXT4_XATTR_INDEX_USER			1
 #define	EXT4_XATTR_INDEX_POSIX_ACL_ACCESS	2
 #define	EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT	3
-#define	EXT4_XATTR_INDEX_TRUSTED			4
-#define	EXT4_XATTR_INDEX_LUSTRE				5
-#define	EXT4_XATTR_INDEX_SECURITY			6
-#define	EXT4_XATTR_INDEX_SYSTEM				7
-#define	EXT4_XATTR_INDEX_RICHACL			8
-#define	EXT4_XATTR_INDEX_ENCRYPTION			9
+#define	EXT4_XATTR_INDEX_TRUSTED		4
+#define	EXT4_XATTR_INDEX_LUSTRE			5
+#define	EXT4_XATTR_INDEX_SECURITY		6
+#define	EXT4_XATTR_INDEX_SYSTEM			7
+#define	EXT4_XATTR_INDEX_RICHACL		8
+#define	EXT4_XATTR_INDEX_ENCRYPTION		9
 
 /* Magic value in attribute blocks */
 #define EXTATTR_MAGIC 0xEA020000
 
+/* Max EA name length */
+#define EXT2_EXTATTR_NAMELEN_MAX		255
+
+/* EA hash constants */
+#define EXT2_EXTATTR_NAME_HASH_SHIFT		5
+#define EXT2_EXTATTR_VALUE_HASH_SHIFT		16
+#define EXT2_EXTATTR_BLOCK_HASH_SHIFT		16
+
+
 struct ext2fs_extattr_header {
 	int32_t	h_magic;	/* magic number for identification */
 	int32_t	h_refcount;	/* reference count */
 	int32_t	h_blocks;	/* number of disk blocks used */
 	int32_t	h_hash;		/* hash value of all attributes */
-	uint32_t	h_reserved[4];	/* zero right now */
+	uint32_t h_reserved[4];	/* zero right now */
 };
 
 struct ext2fs_extattr_dinode_header {
@@ -56,21 +65,15 @@ struct ext2fs_extattr_dinode_header {
 };
 
 struct ext2fs_extattr_entry {
-	uint8_t	e_name_len;			/* length of name */
+	uint8_t	e_name_len;		/* length of name */
 	uint8_t	e_name_index;		/* attribute name index */
 	uint16_t	e_value_offs;	/* offset in disk block of value */
 	uint32_t	e_value_block;	/* disk block attribute is stored on (n/i) */
 	uint32_t	e_value_size;	/* size of attribute value */
-	uint32_t	e_hash;			/* hash value of name and value */
-	char	e_name[0];			/* attribute name */
+	uint32_t	e_hash;		/* hash value of name and value */
+	char	e_name[0];		/* attribute name */
 };
 
-#define EXT2_IHDR(inode, raw_inode) \
-	((struct ext4_xattr_ibody_header *) \
-	    ((void *)raw_inode + \
-	    EXT4_GOOD_OLD_INODE_SIZE + \
-	    EXT4_I(inode)->i_extra_isize))
-
 #define EXT2_IFIRST(hdr) ((struct ext2fs_extattr_entry *)((hdr)+1))
 
 #define EXT2_HDR(bh) ((struct ext2fs_extattr_header *)((bh)->b_data))
@@ -85,10 +88,20 @@ struct ext2fs_extattr_entry {
 	(((name_len) + EXT2_EXTATTR_ROUND + \
 	    sizeof(struct ext2fs_extattr_entry)) & ~EXT2_EXTATTR_ROUND)
 
+#define EXT2_EXTATTR_SIZE(size) \
+    (((size) + EXT2_EXTATTR_ROUND) & ~EXT2_EXTATTR_ROUND)
+
 #define EXT2_EXTATTR_NEXT(entry) \
 	( (struct ext2fs_extattr_entry *)( \
 	    (char *)(entry) + EXT2_EXTATTR_LEN((entry)->e_name_len)) )
 
+int ext2_extattr_inode_delete(struct inode *ip, int attrnamespace,
+    const char *name);
+
+int ext2_extattr_block_delete(struct inode *ip, int attrnamespace,
+    const char *name);
+
+int ext2_extattr_free(struct inode *ip);
 int ext2_extattr_inode_list(struct inode *ip, int attrnamespace,
     struct uio *uio, size_t *size);
 
@@ -101,4 +114,12 @@ int ext2_extattr_inode_get(struct inode *ip, int attrnamespace,
 int ext2_extattr_block_get(struct inode *ip, int attrnamespace,
     const char *name, struct uio *uio, size_t *size);
 
+int ext2_extattr_inode_set(struct inode *ip, int attrnamespace,
+    const char *name, struct uio *uio);
+
+int ext2_extattr_block_set(struct inode *ip, int attrnamespace,
+    const char *name, struct uio *uio);
+
+int ext2_extattr_valid_attrname(int attrnamespace, const char *attrname);
+
 #endif	/* !_FS_EXT2FS_EXT2_EXTARTTR_H_ */
diff --git a/sys/fs/ext2fs/ext2_extern.h b/sys/fs/ext2fs/ext2_extern.h
index 3f4654f77e7e..9a72e5fab07d 100644
--- a/sys/fs/ext2fs/ext2_extern.h
+++ b/sys/fs/ext2fs/ext2_extern.h
@@ -51,6 +51,7 @@ struct vnode;
 int	ext2_add_entry(struct vnode *, struct ext2fs_direct_2 *);
 int	ext2_alloc(struct inode *, daddr_t, e4fs_daddr_t, int,
 	    struct ucred *, e4fs_daddr_t *);
+daddr_t ext2_allocfacl(struct inode *ip);
 int	ext2_balloc(struct inode *,
 	    e2fs_lbn_t, int, struct ucred *, struct buf **, int);
 int	ext2_blkatoff(struct vnode *, off_t, char **, struct buf **);
diff --git a/sys/fs/ext2fs/ext2_inode.c b/sys/fs/ext2fs/ext2_inode.c
index 44e9295c6263..d153bf8257df 100644
--- a/sys/fs/ext2fs/ext2_inode.c
+++ b/sys/fs/ext2fs/ext2_inode.c
@@ -53,6 +53,7 @@
 #include <fs/ext2fs/ext2fs.h>
 #include <fs/ext2fs/fs.h>
 #include <fs/ext2fs/ext2_extern.h>
+#include <fs/ext2fs/ext2_extattr.h>
 
 static int ext2_indirtrunc(struct inode *, daddr_t, daddr_t,
 	    daddr_t, int, e4fs_daddr_t *);
@@ -488,6 +489,7 @@ ext2_inactive(struct vop_inactive_args *ap)
 	if (ip->i_mode == 0)
 		goto out;
 	if (ip->i_nlink <= 0) {
+		ext2_extattr_free(ip);
 		error = ext2_truncate(vp, (off_t)0, 0, NOCRED, td);
 		ip->i_rdev = 0;
 		mode = ip->i_mode;
diff --git a/sys/fs/ext2fs/ext2_inode_cnv.c b/sys/fs/ext2fs/ext2_inode_cnv.c
index aabf4df37268..64ef17667e8d 100644
--- a/sys/fs/ext2fs/ext2_inode_cnv.c
+++ b/sys/fs/ext2fs/ext2_inode_cnv.c
@@ -51,8 +51,8 @@ ext2_print_inode(struct inode *in)
 
 	printf("Inode: %5ju", (uintmax_t)in->i_number);
 	printf(	/* "Inode: %5d" */
-	    " Type: %10s Mode: 0x%o Flags: 0x%x  Version: %d\n",
-	    "n/a", in->i_mode, in->i_flags, in->i_gen);
+	    " Type: %10s Mode: 0x%o Flags: 0x%x  Version: %d acl: 0x%llx\n",
+	    "n/a", in->i_mode, in->i_flags, in->i_gen, in->i_facl);
 	printf("User: %5u Group: %5u  Size: %ju\n",
 	    in->i_uid, in->i_gid, (uintmax_t)in->i_size);
 	printf("Links: %3d Blockcount: %ju\n",
@@ -167,6 +167,8 @@ ext2_i2ei(struct inode *ip, struct ext2fs_dinode *ei)
 	ei->e2di_flags |= (ip->i_flag & IN_E4EXTENTS) ? EXT4_EXTENTS : 0;
 	ei->e2di_nblock = ip->i_blocks & 0xffffffff;
 	ei->e2di_nblock_high = ip->i_blocks >> 32 & 0xffff;
+	ei->e2di_facl = ip->i_facl & 0xffffffff;
+	ei->e2di_facl_high = ip->i_facl >> 32 & 0xffff;
 	ei->e2di_gen = ip->i_gen;
 	ei->e2di_uid = ip->i_uid;
 	ei->e2di_gid = ip->i_gid;
diff --git a/sys/fs/ext2fs/ext2_vnops.c b/sys/fs/ext2fs/ext2_vnops.c
index b88d7219a3aa..b507a6200886 100644
--- a/sys/fs/ext2fs/ext2_vnops.c
+++ b/sys/fs/ext2fs/ext2_vnops.c
@@ -117,8 +117,10 @@ static vop_setattr_t	ext2_setattr;
 static vop_strategy_t	ext2_strategy;
 static vop_symlink_t	ext2_symlink;
 static vop_write_t	ext2_write;
+static vop_deleteextattr_t	ext2_deleteextattr;
 static vop_getextattr_t	ext2_getextattr;
 static vop_listextattr_t	ext2_listextattr;
+static vop_setextattr_t	ext2_setextattr;
 static vop_vptofh_t	ext2_vptofh;
 static vop_close_t	ext2fifo_close;
 static vop_kqfilter_t	ext2fifo_kqfilter;
@@ -157,8 +159,10 @@ struct vop_vector ext2_vnodeops = {
 	.vop_strategy =		ext2_strategy,
 	.vop_symlink =		ext2_symlink,
 	.vop_write =		ext2_write,
+	.vop_deleteextattr =	ext2_deleteextattr,
 	.vop_getextattr =	ext2_getextattr,
 	.vop_listextattr =	ext2_listextattr,
+	.vop_setextattr =	ext2_setextattr,
 	.vop_vptofh =		ext2_vptofh,
 };
 
@@ -1485,6 +1489,42 @@ ext2_pathconf(struct vop_pathconf_args *ap)
 	return (error);
 }
 
+/*
+ * Vnode operation to remove a named attribute.
+ */
+static int
+ext2_deleteextattr(struct vop_deleteextattr_args *ap)
+{
+	struct inode *ip;
+	struct m_ext2fs *fs;
+	int error;
+
+	ip = VTOI(ap->a_vp);
+	fs = ip->i_e2fs;
+
+	if (!EXT2_HAS_COMPAT_FEATURE(ip->i_e2fs, EXT2F_COMPAT_EXT_ATTR))
+		return (EOPNOTSUPP);
+
+	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
+		return (EOPNOTSUPP);
+
+	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
+	    ap->a_cred, ap->a_td, VWRITE);
+	if (error)
+		return (error);
+
+	if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {
+		error = ext2_extattr_inode_delete(ip, ap->a_attrnamespace, ap->a_name);
+		if (error != ENOATTR)
+			return (error);
+	}
+
+	if (ip->i_facl)
+		error = ext2_extattr_block_delete(ip, ap->a_attrnamespace, ap->a_name);
+
+	return (error);
+}
+
 /*
  * Vnode operation to retrieve a named extended attribute.
  */
@@ -1515,7 +1555,7 @@ ext2_getextattr(struct vop_getextattr_args *ap)
 	if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {
 		error = ext2_extattr_inode_get(ip, ap->a_attrnamespace,
 		    ap->a_name, ap->a_uio, ap->a_size);
-		if (error)
+		if (error != ENOATTR)
 			return (error);
 	}
 
@@ -1556,17 +1596,58 @@ ext2_listextattr(struct vop_listextattr_args *ap)
 	if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {
 		error = ext2_extattr_inode_list(ip, ap->a_attrnamespace,
 		    ap->a_uio, ap->a_size);
-		if(error)
+		if (error)
 			return (error);
 	}
 
-	if(ip->i_facl)
+	if (ip->i_facl)
 		error = ext2_extattr_block_list(ip, ap->a_attrnamespace,
 		    ap->a_uio, ap->a_size);
 
 	return (error);
 }
 
+/*
+ * Vnode operation to set a named attribute.
+ */
+static int
+ext2_setextattr(struct vop_setextattr_args *ap)
+{
+	struct inode *ip;
+	struct m_ext2fs *fs;
+	int error;
+
+	ip = VTOI(ap->a_vp);
+	fs = ip->i_e2fs;
+
+	if (!EXT2_HAS_COMPAT_FEATURE(ip->i_e2fs, EXT2F_COMPAT_EXT_ATTR))
+		return (EOPNOTSUPP);
+
+	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
+		return (EOPNOTSUPP);
+
+	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
+	    ap->a_cred, ap->a_td, VWRITE);
+	if (error)
+		return (error);
+
+	error = ext2_extattr_valid_attrname(ap->a_attrnamespace, ap->a_name);
+	if (error)
+		return (error);
+
+	if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {
+		error = ext2_extattr_inode_set(ip, ap->a_attrnamespace,
+		    ap->a_name, ap->a_uio);
+		if (error != ENOSPC)
+			return (error);
+	}
+
+	error = ext2_extattr_block_set(ip, ap->a_attrnamespace,
+	    ap->a_name, ap->a_uio);
+
+	return (error);
+}
+
 /*
  * Vnode pointer to File handle
  */