1 Index: linux-2.6.16-sles10/fs/ext3/inode.c
2 ===================================================================
3 --- linux-2.6.16-sles10.orig/fs/ext3/inode.c
4 +++ linux-2.6.16-sles10/fs/ext3/inode.c
5 @@ -2561,6 +2561,13 @@ void ext3_read_inode(struct inode * inod
6 EXT3_INODE_GET_XTIME(i_atime, inode, raw_inode);
7 EXT3_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
9 + ei->i_fs_version = le32_to_cpu(raw_inode->i_disk_version);
10 + if (EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
11 + if (EXT3_FITS_IN_INODE(raw_inode, ei, i_version_hi))
12 + ei->i_fs_version |= (__u64)(le32_to_cpu(raw_inode->i_version_hi))
16 if (S_ISREG(inode->i_mode)) {
17 inode->i_op = &ext3_file_inode_operations;
18 inode->i_fop = &ext3_file_operations;
19 @@ -2699,8 +2706,14 @@ static int ext3_do_update_inode(handle_t
20 } else for (block = 0; block < EXT3_N_BLOCKS; block++)
21 raw_inode->i_block[block] = ei->i_data[block];
23 - if (ei->i_extra_isize)
24 + raw_inode->i_disk_version = cpu_to_le32(ei->i_fs_version);
25 + if (ei->i_extra_isize) {
26 + if (EXT3_FITS_IN_INODE(raw_inode, ei, i_version_hi)) {
27 + raw_inode->i_version_hi = cpu_to_le32(ei->i_fs_version
30 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
33 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
34 rc = ext3_journal_dirty_metadata(handle, bh);
35 @@ -2974,10 +2987,32 @@ ext3_reserve_inode_write(handle_t *handl
36 int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
38 struct ext3_iloc iloc;
41 + static int expand_message;
44 err = ext3_reserve_inode_write(handle, inode, &iloc);
45 + if (EXT3_I(inode)->i_extra_isize <
46 + EXT3_SB(inode->i_sb)->s_want_extra_isize &&
47 + !(EXT3_I(inode)->i_state & EXT3_STATE_NO_EXPAND)) {
48 + /* We need extra buffer credits since we may write into EA block
49 + * with this same handle */
50 + if ((ext3_journal_extend(handle,
51 + EXT3_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
52 + ret = ext3_expand_extra_isize(inode,
53 + EXT3_SB(inode->i_sb)->s_want_extra_isize,
56 + EXT3_I(inode)->i_state |= EXT3_STATE_NO_EXPAND;
57 + if (!expand_message) {
58 + ext3_warning(inode->i_sb, __FUNCTION__,
59 + "Unable to expand inode %lu. Delete some"
60 + " EAs or run e2fsck.", inode->i_ino);
67 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
69 Index: linux-2.6.16-sles10/include/linux/ext3_fs.h
70 ===================================================================
71 --- linux-2.6.16-sles10.orig/include/linux/ext3_fs.h
72 +++ linux-2.6.16-sles10/include/linux/ext3_fs.h
73 @@ -227,6 +227,7 @@ struct ext3_group_desc
74 #define EXT3_STATE_JDATA 0x00000001 /* journaled data exists */
75 #define EXT3_STATE_NEW 0x00000002 /* inode is newly created */
76 #define EXT3_STATE_XATTR 0x00000004 /* has in-inode xattrs */
77 +#define EXT3_STATE_NO_EXPAND 0x00000008 /* No space for expansion */
79 /* Used to pass group descriptor data when online resize is done */
80 struct ext3_new_group_input {
81 @@ -303,7 +304,7 @@ struct ext3_inode {
82 __le32 i_flags; /* File flags */
85 - __u32 l_i_reserved1;
90 @@ -348,6 +349,7 @@ struct ext3_inode {
91 __le32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
92 __le32 i_crtime; /* File Creation time */
93 __le32 i_crtime_extra; /* extra File Creation time (nsec << 2 | epoch) */
94 + __le32 i_version_hi; /* high 32 bits for 64-bit version */
97 #define i_size_high i_dir_acl
98 @@ -410,6 +412,8 @@ do { \
99 raw_inode->xtime ## _extra); \
102 +#define i_disk_version osd1.linux1.l_i_version
104 #if defined(__KERNEL__) || defined(__linux__)
105 #define i_reserved1 osd1.linux1.l_i_reserved1
106 #define i_frag osd2.linux2.l_i_frag
107 Index: linux-2.6.16-sles10/include/linux/ext3_fs_i.h
108 ===================================================================
109 --- linux-2.6.16-sles10.orig/include/linux/ext3_fs_i.h
110 +++ linux-2.6.16-sles10/include/linux/ext3_fs_i.h
112 #include <linux/rbtree.h>
113 #include <linux/seqlock.h>
115 +#define HAVE_DISK_INODE_VERSION
117 struct ext3_reserve_window {
118 __u32 _rsv_start; /* First byte reserved */
119 __u32 _rsv_end; /* Last byte reserved or 0 */
120 @@ -142,6 +144,8 @@ struct ext3_inode_info {
121 spinlock_t i_prealloc_lock;
125 + __u64 i_fs_version;
128 #endif /* _LINUX_EXT3_FS_I */
129 Index: linux-2.6.16-sles10/fs/ext3/xattr.c
130 ===================================================================
131 --- linux-2.6.16-sles10.orig/fs/ext3/xattr.c
132 +++ linux-2.6.16-sles10/fs/ext3/xattr.c
133 @@ -505,6 +505,20 @@ ext3_xattr_release_block(handle_t *handl
137 +static inline size_t ext3_xattr_free_space(struct ext3_xattr_entry *last,
138 + size_t *min_offs, void *base, int *total)
140 + for (; !IS_LAST_ENTRY(last); last = EXT3_XATTR_NEXT(last)) {
141 + *total += EXT3_XATTR_LEN(last->e_name_len);
142 + if (!last->e_value_block && last->e_value_size) {
143 + size_t offs = le16_to_cpu(last->e_value_offs);
144 + if (offs < *min_offs)
148 + return (*min_offs - ((void *)last - base) - sizeof(__u32));
151 struct ext3_xattr_info {
154 @@ -944,13 +958,18 @@ ext3_xattr_set_handle(handle_t *handle,
155 struct ext3_xattr_block_find bs = {
156 .s = { .not_found = -ENODATA, },
158 + unsigned long no_expand;
163 if (strlen(name) > 255)
166 down_write(&EXT3_I(inode)->xattr_sem);
167 + no_expand = EXT3_I(inode)->i_state & EXT3_STATE_NO_EXPAND;
168 + EXT3_I(inode)->i_state |= EXT3_STATE_NO_EXPAND;
170 error = ext3_get_inode_loc(inode, &is.iloc);
173 @@ -1007,7 +1026,10 @@ ext3_xattr_set_handle(handle_t *handle,
175 ext3_xattr_update_super_block(handle, inode->i_sb);
176 inode->i_ctime = ext3_current_time(inode);
178 error = ext3_mark_iloc_dirty(handle, inode, &is.iloc);
180 + EXT3_I(inode)->i_state &= ~EXT3_STATE_NO_EXPAND;
182 * The bh is consumed by ext3_mark_iloc_dirty, even with
184 @@ -1020,6 +1042,8 @@ ext3_xattr_set_handle(handle_t *handle,
188 + if (no_expand == 0)
189 + EXT3_I(inode)->i_state &= ~EXT3_STATE_NO_EXPAND;
190 up_write(&EXT3_I(inode)->xattr_sem);
193 @@ -1059,6 +1083,249 @@ retry:
197 +static void ext3_xattr_shift_entries(struct ext3_xattr_entry *entry,
198 + int value_offs_shift, void *to,
199 + void *from, size_t n, int blocksize)
201 + struct ext3_xattr_entry *last = entry;
204 + /* Adjust the value offsets of the entries */
205 + for (; !IS_LAST_ENTRY(last); last = EXT3_XATTR_NEXT(last)) {
206 + if (!last->e_value_block && last->e_value_size) {
207 + new_offs = le16_to_cpu(last->e_value_offs) +
209 + BUG_ON(new_offs + le32_to_cpu(last->e_value_size) >
211 + last->e_value_offs = cpu_to_le16(new_offs);
214 + /* Shift the entries by n bytes */
215 + memmove(to, from, n);
218 +/* Expand an inode by new_extra_isize bytes.
219 + * Returns 0 on success or negative error number on failure.
221 +int ext3_expand_extra_isize(struct inode *inode, int new_extra_isize,
222 + struct ext3_iloc iloc, handle_t *handle)
224 + struct ext3_inode *raw_inode;
225 + struct ext3_xattr_ibody_header *header;
226 + struct ext3_xattr_entry *entry, *last, *first;
227 + struct buffer_head *bh = NULL;
228 + struct ext3_xattr_ibody_find *is = NULL;
229 + struct ext3_xattr_block_find *bs = NULL;
230 + char *buffer = NULL, *b_entry_name = NULL;
231 + size_t min_offs, free;
232 + int total_ino, total_blk;
233 + void *base, *start, *end;
234 + int extra_isize = 0, error = 0, tried_min_extra_isize = 0;
235 + int s_min_extra_isize = EXT3_SB(inode->i_sb)->s_es->s_min_extra_isize;
237 + down_write(&EXT3_I(inode)->xattr_sem);
240 + if (EXT3_I(inode)->i_extra_isize >= new_extra_isize) {
241 + up_write(&EXT3_I(inode)->xattr_sem);
245 + raw_inode = ext3_raw_inode(&iloc);
247 + header = IHDR(inode, raw_inode);
248 + entry = IFIRST(header);
250 + /* No extended attributes present */
251 + if (!(EXT3_I(inode)->i_state & EXT3_STATE_XATTR) ||
252 + header->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC)) {
253 + memset((void *)raw_inode + EXT3_GOOD_OLD_INODE_SIZE, 0,
255 + EXT3_I(inode)->i_extra_isize = new_extra_isize;
260 + * Check if enough free space is available in the inode to shift the
261 + * entries ahead by new_extra_isize.
264 + base = start = entry;
265 + end = (void *)raw_inode + EXT3_SB(inode->i_sb)->s_inode_size;
266 + min_offs = end - base;
268 + total_ino = sizeof(struct ext3_xattr_ibody_header);
270 + free = ext3_xattr_free_space(last, &min_offs, base, &total_ino);
271 + if (free >= new_extra_isize) {
272 + entry = IFIRST(header);
273 + ext3_xattr_shift_entries(entry, EXT3_I(inode)->i_extra_isize -
274 + new_extra_isize, (void *)raw_inode +
275 + EXT3_GOOD_OLD_INODE_SIZE + new_extra_isize,
276 + (void *)header, total_ino,
277 + inode->i_sb->s_blocksize);
278 + EXT3_I(inode)->i_extra_isize = new_extra_isize;
284 + * Enough free space isn't available in the inode, check if
285 + * EA block can hold new_extra_isize bytes.
287 + if (EXT3_I(inode)->i_file_acl) {
288 + bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
292 + if (ext3_xattr_check_block(bh)) {
293 + ext3_error(inode->i_sb, __FUNCTION__,
294 + "inode %lu: bad block %d", inode->i_ino,
295 + EXT3_I(inode)->i_file_acl);
300 + first = BFIRST(bh);
301 + end = bh->b_data + bh->b_size;
302 + min_offs = end - base;
303 + free = ext3_xattr_free_space(first, &min_offs, base,
305 + if (free < new_extra_isize) {
306 + if (!tried_min_extra_isize && s_min_extra_isize) {
307 + tried_min_extra_isize++;
308 + new_extra_isize = s_min_extra_isize;
315 + free = inode->i_sb->s_blocksize;
318 + while (new_extra_isize > 0) {
319 + size_t offs, size, entry_size;
320 + struct ext3_xattr_entry *small_entry = NULL;
321 + struct ext3_xattr_info i = {
325 + unsigned int total_size, shift_bytes, temp = ~0U;
327 + is = (struct ext3_xattr_ibody_find *) kmalloc(sizeof(struct
328 + ext3_xattr_ibody_find), GFP_KERNEL);
329 + bs = (struct ext3_xattr_block_find *) kmalloc(sizeof(struct
330 + ext3_xattr_block_find), GFP_KERNEL);
331 + memset((void *)is, 0, sizeof(struct ext3_xattr_ibody_find));
332 + memset((void *)bs, 0, sizeof(struct ext3_xattr_block_find));
334 + is->s.not_found = bs->s.not_found = -ENODATA;
335 + is->iloc.bh = NULL;
338 + last = IFIRST(header);
339 + /* Find the entry best suited to be pushed into EA block */
341 + for (; !IS_LAST_ENTRY(last); last = EXT3_XATTR_NEXT(last)) {
342 + total_size = EXT3_XATTR_SIZE(le32_to_cpu(last->e_value_size)) +
343 + EXT3_XATTR_LEN(last->e_name_len);
344 + if (total_size <= free && total_size < temp) {
345 + if (total_size < new_extra_isize) {
346 + small_entry = last;
354 + if (entry == NULL) {
356 + entry = small_entry;
358 + if (!tried_min_extra_isize &&
359 + s_min_extra_isize) {
360 + tried_min_extra_isize++;
361 + new_extra_isize = s_min_extra_isize;
368 + offs = le16_to_cpu(entry->e_value_offs);
369 + size = le32_to_cpu(entry->e_value_size);
370 + entry_size = EXT3_XATTR_LEN(entry->e_name_len);
371 + i.name_index = entry->e_name_index,
372 + buffer = kmalloc(EXT3_XATTR_SIZE(size), GFP_KERNEL);
373 + b_entry_name = kmalloc(entry->e_name_len + 1, GFP_KERNEL);
374 + /* Save the entry name and the entry value */
375 + memcpy((void *)buffer, (void *)IFIRST(header) + offs,
376 + EXT3_XATTR_SIZE(size));
377 + memcpy((void *)b_entry_name, (void *)entry->e_name,
378 + entry->e_name_len);
379 + b_entry_name[entry->e_name_len] = '\0';
380 + i.name = b_entry_name;
382 + error = ext3_get_inode_loc(inode, &is->iloc);
386 + error = ext3_xattr_ibody_find(inode, &i, is);
390 + /* Remove the chosen entry from the inode */
391 + error = ext3_xattr_ibody_set(handle, inode, &i, is);
393 + entry = IFIRST(header);
394 + if (entry_size + EXT3_XATTR_SIZE(size) >= new_extra_isize)
395 + shift_bytes = new_extra_isize;
397 + shift_bytes = entry_size + size;
398 + /* Adjust the offsets and shift the remaining entries ahead */
399 + ext3_xattr_shift_entries(entry, EXT3_I(inode)->i_extra_isize -
400 + shift_bytes, (void *)raw_inode +
401 + EXT3_GOOD_OLD_INODE_SIZE + extra_isize + shift_bytes,
402 + (void *)header, total_ino - entry_size,
403 + inode->i_sb->s_blocksize);
405 + extra_isize += shift_bytes;
406 + new_extra_isize -= shift_bytes;
407 + EXT3_I(inode)->i_extra_isize = extra_isize;
409 + i.name = b_entry_name;
411 + i.value_len = cpu_to_le32(size);
412 + error = ext3_xattr_block_find(inode, &i, bs);
416 + /* Add entry which was removed from the inode into the block */
417 + error = ext3_xattr_block_set(handle, inode, &i, bs);
424 + kfree(b_entry_name);
428 + brelse(is->iloc.bh);
434 + up_write(&EXT3_I(inode)->xattr_sem);
441 * ext3_xattr_delete_inode()
443 Index: linux-2.6.16-sles10/fs/ext3/xattr.h
444 ===================================================================
445 --- linux-2.6.16-sles10.orig/fs/ext3/xattr.h
446 +++ linux-2.6.16-sles10/fs/ext3/xattr.h
447 @@ -75,6 +75,9 @@ extern int ext3_xattr_set_handle(handle_
448 extern void ext3_xattr_delete_inode(handle_t *, struct inode *);
449 extern void ext3_xattr_put_super(struct super_block *);
451 +int ext3_expand_extra_isize(struct inode *inode, int new_extra_isize,
452 + struct ext3_iloc iloc, handle_t *handle);
454 extern int init_ext3_xattr(void);
455 extern void exit_ext3_xattr(void);
457 Index: linux-2.6.16-sles10/fs/ext3/ialloc.c
458 ===================================================================
459 --- linux-2.6.16-sles10.orig/fs/ext3/ialloc.c
460 +++ linux-2.6.16-sles10/fs/ext3/ialloc.c
461 @@ -750,6 +750,7 @@ got:
463 ei->i_block_alloc_info = NULL;
464 ei->i_block_group = group;
465 + ei->i_fs_version = 0;
467 ext3_set_inode_flags(inode);
468 if (IS_DIRSYNC(inode))