2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/xattr.h>
15 #include <linux/gfs2_ondisk.h>
16 #include <linux/posix_acl_xattr.h>
17 #include <asm/uaccess.h>
32 * ea_calc_size - returns the acutal number of bytes the request will take up
33 * (not counting any unstuffed data blocks)
38 * Returns: 1 if the EA should be stuffed
41 static int ea_calc_size(struct gfs2_sbd
*sdp
, unsigned int nsize
, size_t dsize
,
44 unsigned int jbsize
= sdp
->sd_jbsize
;
47 *size
= ALIGN(sizeof(struct gfs2_ea_header
) + nsize
+ dsize
, 8);
53 *size
= ALIGN(sizeof(struct gfs2_ea_header
) + nsize
+
54 (sizeof(__be64
) * DIV_ROUND_UP(dsize
, jbsize
)), 8);
59 static int ea_check_size(struct gfs2_sbd
*sdp
, unsigned int nsize
, size_t dsize
)
63 if (dsize
> GFS2_EA_MAX_DATA_LEN
)
66 ea_calc_size(sdp
, nsize
, dsize
, &size
);
68 /* This can only happen with 512 byte blocks */
69 if (size
> sdp
->sd_jbsize
)
75 typedef int (*ea_call_t
) (struct gfs2_inode
*ip
, struct buffer_head
*bh
,
76 struct gfs2_ea_header
*ea
,
77 struct gfs2_ea_header
*prev
, void *private);
79 static int ea_foreach_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
80 ea_call_t ea_call
, void *data
)
82 struct gfs2_ea_header
*ea
, *prev
= NULL
;
85 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), bh
, GFS2_METATYPE_EA
))
88 for (ea
= GFS2_EA_BH2FIRST(bh
);; prev
= ea
, ea
= GFS2_EA2NEXT(ea
)) {
89 if (!GFS2_EA_REC_LEN(ea
))
91 if (!(bh
->b_data
<= (char *)ea
&& (char *)GFS2_EA2NEXT(ea
) <=
92 bh
->b_data
+ bh
->b_size
))
94 if (!GFS2_EATYPE_VALID(ea
->ea_type
))
97 error
= ea_call(ip
, bh
, ea
, prev
, data
);
101 if (GFS2_EA_IS_LAST(ea
)) {
102 if ((char *)GFS2_EA2NEXT(ea
) !=
103 bh
->b_data
+ bh
->b_size
)
112 gfs2_consist_inode(ip
);
116 static int ea_foreach(struct gfs2_inode
*ip
, ea_call_t ea_call
, void *data
)
118 struct buffer_head
*bh
, *eabh
;
122 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, &bh
);
126 if (!(ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
)) {
127 error
= ea_foreach_i(ip
, bh
, ea_call
, data
);
131 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), bh
, GFS2_METATYPE_IN
)) {
136 eablk
= (__be64
*)(bh
->b_data
+ sizeof(struct gfs2_meta_header
));
137 end
= eablk
+ GFS2_SB(&ip
->i_inode
)->sd_inptrs
;
139 for (; eablk
< end
; eablk
++) {
144 bn
= be64_to_cpu(*eablk
);
146 error
= gfs2_meta_read(ip
->i_gl
, bn
, DIO_WAIT
, &eabh
);
149 error
= ea_foreach_i(ip
, eabh
, ea_call
, data
);
163 struct gfs2_ea_location
*ef_el
;
166 static int ea_find_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
167 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
170 struct ea_find
*ef
= private;
172 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
)
175 if (ea
->ea_type
== ef
->type
) {
176 if (ea
->ea_name_len
== ef
->namel
&&
177 !memcmp(GFS2_EA2NAME(ea
), ef
->name
, ea
->ea_name_len
)) {
178 struct gfs2_ea_location
*el
= ef
->ef_el
;
190 static int gfs2_ea_find(struct gfs2_inode
*ip
, int type
, const char *name
,
191 struct gfs2_ea_location
*el
)
198 ef
.namel
= strlen(name
);
201 memset(el
, 0, sizeof(struct gfs2_ea_location
));
203 error
= ea_foreach(ip
, ea_find_i
, &ef
);
211 * ea_dealloc_unstuffed -
218 * Take advantage of the fact that all unstuffed blocks are
219 * allocated from the same RG. But watch, this may not always
225 static int ea_dealloc_unstuffed(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
226 struct gfs2_ea_header
*ea
,
227 struct gfs2_ea_header
*prev
, void *private)
229 int *leave
= private;
230 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
231 struct gfs2_rgrpd
*rgd
;
232 struct gfs2_holder rg_gh
;
233 struct buffer_head
*dibh
;
237 unsigned int blen
= 0;
238 unsigned int blks
= 0;
242 error
= gfs2_rindex_update(sdp
);
246 if (GFS2_EA_IS_STUFFED(ea
))
249 dataptrs
= GFS2_EA2DATAPTRS(ea
);
250 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++, dataptrs
++) {
253 bn
= be64_to_cpu(*dataptrs
);
259 rgd
= gfs2_blk2rgrpd(sdp
, bn
, 1);
261 gfs2_consist_inode(ip
);
265 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0, &rg_gh
);
269 error
= gfs2_trans_begin(sdp
, rgd
->rd_length
+ RES_DINODE
+
270 RES_EATTR
+ RES_STATFS
+ RES_QUOTA
, blks
);
274 gfs2_trans_add_meta(ip
->i_gl
, bh
);
276 dataptrs
= GFS2_EA2DATAPTRS(ea
);
277 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++, dataptrs
++) {
280 bn
= be64_to_cpu(*dataptrs
);
282 if (bstart
+ blen
== bn
)
286 gfs2_free_meta(ip
, bstart
, blen
);
292 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
295 gfs2_free_meta(ip
, bstart
, blen
);
297 if (prev
&& !leave
) {
300 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
301 prev
->ea_rec_len
= cpu_to_be32(len
);
303 if (GFS2_EA_IS_LAST(ea
))
304 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
306 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
310 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
312 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
313 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
314 gfs2_dinode_out(ip
, dibh
->b_data
);
321 gfs2_glock_dq_uninit(&rg_gh
);
325 static int ea_remove_unstuffed(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
326 struct gfs2_ea_header
*ea
,
327 struct gfs2_ea_header
*prev
, int leave
)
331 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
335 error
= gfs2_quota_hold(ip
, NO_UID_QUOTA_CHANGE
, NO_GID_QUOTA_CHANGE
);
339 error
= ea_dealloc_unstuffed(ip
, bh
, ea
, prev
, (leave
) ? &error
: NULL
);
341 gfs2_quota_unhold(ip
);
347 struct gfs2_ea_request
*ei_er
;
348 unsigned int ei_size
;
351 static inline unsigned int gfs2_ea_strlen(struct gfs2_ea_header
*ea
)
353 switch (ea
->ea_type
) {
354 case GFS2_EATYPE_USR
:
355 return 5 + ea
->ea_name_len
+ 1;
356 case GFS2_EATYPE_SYS
:
357 return 7 + ea
->ea_name_len
+ 1;
358 case GFS2_EATYPE_SECURITY
:
359 return 9 + ea
->ea_name_len
+ 1;
365 static int ea_list_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
366 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
369 struct ea_list
*ei
= private;
370 struct gfs2_ea_request
*er
= ei
->ei_er
;
371 unsigned int ea_size
= gfs2_ea_strlen(ea
);
373 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
)
376 if (er
->er_data_len
) {
381 if (ei
->ei_size
+ ea_size
> er
->er_data_len
)
384 switch (ea
->ea_type
) {
385 case GFS2_EATYPE_USR
:
389 case GFS2_EATYPE_SYS
:
393 case GFS2_EATYPE_SECURITY
:
394 prefix
= "security.";
401 memcpy(er
->er_data
+ ei
->ei_size
, prefix
, l
);
402 memcpy(er
->er_data
+ ei
->ei_size
+ l
, GFS2_EA2NAME(ea
),
404 memcpy(er
->er_data
+ ei
->ei_size
+ ea_size
- 1, &c
, 1);
407 ei
->ei_size
+= ea_size
;
413 * gfs2_listxattr - List gfs2 extended attributes
414 * @dentry: The dentry whose inode we are interested in
415 * @buffer: The buffer to write the results
416 * @size: The size of the buffer
418 * Returns: actual size of data on success, -errno on error
421 ssize_t
gfs2_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
423 struct gfs2_inode
*ip
= GFS2_I(d_inode(dentry
));
424 struct gfs2_ea_request er
;
425 struct gfs2_holder i_gh
;
428 memset(&er
, 0, sizeof(struct gfs2_ea_request
));
431 er
.er_data_len
= size
;
434 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &i_gh
);
439 struct ea_list ei
= { .ei_er
= &er
, .ei_size
= 0 };
441 error
= ea_foreach(ip
, ea_list_i
, &ei
);
446 gfs2_glock_dq_uninit(&i_gh
);
452 * ea_iter_unstuffed - copies the unstuffed xattr data to/from the
454 * @ip: The GFS2 inode
455 * @ea: The extended attribute header structure
456 * @din: The data to be copied in
457 * @dout: The data to be copied out (one of din,dout will be NULL)
462 static int gfs2_iter_unstuffed(struct gfs2_inode
*ip
, struct gfs2_ea_header
*ea
,
463 const char *din
, char *dout
)
465 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
466 struct buffer_head
**bh
;
467 unsigned int amount
= GFS2_EA_DATA_LEN(ea
);
468 unsigned int nptrs
= DIV_ROUND_UP(amount
, sdp
->sd_jbsize
);
469 __be64
*dataptrs
= GFS2_EA2DATAPTRS(ea
);
475 bh
= kcalloc(nptrs
, sizeof(struct buffer_head
*), GFP_NOFS
);
479 for (x
= 0; x
< nptrs
; x
++) {
480 error
= gfs2_meta_read(ip
->i_gl
, be64_to_cpu(*dataptrs
), 0,
490 for (x
= 0; x
< nptrs
; x
++) {
491 error
= gfs2_meta_wait(sdp
, bh
[x
]);
493 for (; x
< nptrs
; x
++)
497 if (gfs2_metatype_check(sdp
, bh
[x
], GFS2_METATYPE_ED
)) {
498 for (; x
< nptrs
; x
++)
504 pos
= bh
[x
]->b_data
+ sizeof(struct gfs2_meta_header
);
505 cp_size
= (sdp
->sd_jbsize
> amount
) ? amount
: sdp
->sd_jbsize
;
508 memcpy(dout
, pos
, cp_size
);
509 dout
+= sdp
->sd_jbsize
;
513 gfs2_trans_add_meta(ip
->i_gl
, bh
[x
]);
514 memcpy(pos
, din
, cp_size
);
515 din
+= sdp
->sd_jbsize
;
518 amount
-= sdp
->sd_jbsize
;
527 static int gfs2_ea_get_copy(struct gfs2_inode
*ip
, struct gfs2_ea_location
*el
,
528 char *data
, size_t size
)
531 size_t len
= GFS2_EA_DATA_LEN(el
->el_ea
);
535 if (GFS2_EA_IS_STUFFED(el
->el_ea
)) {
536 memcpy(data
, GFS2_EA2DATA(el
->el_ea
), len
);
539 ret
= gfs2_iter_unstuffed(ip
, el
->el_ea
, NULL
, data
);
545 int gfs2_xattr_acl_get(struct gfs2_inode
*ip
, const char *name
, char **ppdata
)
547 struct gfs2_ea_location el
;
552 error
= gfs2_ea_find(ip
, GFS2_EATYPE_SYS
, name
, &el
);
557 if (!GFS2_EA_DATA_LEN(el
.el_ea
))
560 len
= GFS2_EA_DATA_LEN(el
.el_ea
);
561 data
= kmalloc(len
, GFP_NOFS
);
566 error
= gfs2_ea_get_copy(ip
, &el
, data
, len
);
577 * gfs2_xattr_get - Get a GFS2 extended attribute
579 * @name: The name of the extended attribute
580 * @buffer: The buffer to write the result into
581 * @size: The size of the buffer
582 * @type: The type of extended attribute
584 * Returns: actual size of data on success, -errno on error
586 static int gfs2_xattr_get(const struct xattr_handler
*handler
,
587 struct dentry
*dentry
, const char *name
,
588 void *buffer
, size_t size
)
590 struct gfs2_inode
*ip
= GFS2_I(d_inode(dentry
));
591 struct gfs2_ea_location el
;
592 int type
= handler
->flags
;
597 if (strlen(name
) > GFS2_EA_MAX_NAME_LEN
)
600 error
= gfs2_ea_find(ip
, type
, name
, &el
);
606 error
= gfs2_ea_get_copy(ip
, &el
, buffer
, size
);
608 error
= GFS2_EA_DATA_LEN(el
.el_ea
);
615 * ea_alloc_blk - allocates a new block for extended attributes.
616 * @ip: A pointer to the inode that's getting extended attributes
617 * @bhp: Pointer to pointer to a struct buffer_head
622 static int ea_alloc_blk(struct gfs2_inode
*ip
, struct buffer_head
**bhp
)
624 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
625 struct gfs2_ea_header
*ea
;
630 error
= gfs2_alloc_blocks(ip
, &block
, &n
, 0, NULL
);
633 gfs2_trans_add_unrevoke(sdp
, block
, 1);
634 *bhp
= gfs2_meta_new(ip
->i_gl
, block
);
635 gfs2_trans_add_meta(ip
->i_gl
, *bhp
);
636 gfs2_metatype_set(*bhp
, GFS2_METATYPE_EA
, GFS2_FORMAT_EA
);
637 gfs2_buffer_clear_tail(*bhp
, sizeof(struct gfs2_meta_header
));
639 ea
= GFS2_EA_BH2FIRST(*bhp
);
640 ea
->ea_rec_len
= cpu_to_be32(sdp
->sd_jbsize
);
641 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
642 ea
->ea_flags
= GFS2_EAFLAG_LAST
;
645 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
651 * ea_write - writes the request info to an ea, creating new blocks if
653 * @ip: inode that is being modified
654 * @ea: the location of the new ea in a block
655 * @er: the write request
657 * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
662 static int ea_write(struct gfs2_inode
*ip
, struct gfs2_ea_header
*ea
,
663 struct gfs2_ea_request
*er
)
665 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
668 ea
->ea_data_len
= cpu_to_be32(er
->er_data_len
);
669 ea
->ea_name_len
= er
->er_name_len
;
670 ea
->ea_type
= er
->er_type
;
673 memcpy(GFS2_EA2NAME(ea
), er
->er_name
, er
->er_name_len
);
675 if (GFS2_EAREQ_SIZE_STUFFED(er
) <= sdp
->sd_jbsize
) {
677 memcpy(GFS2_EA2DATA(ea
), er
->er_data
, er
->er_data_len
);
679 __be64
*dataptr
= GFS2_EA2DATAPTRS(ea
);
680 const char *data
= er
->er_data
;
681 unsigned int data_len
= er
->er_data_len
;
685 ea
->ea_num_ptrs
= DIV_ROUND_UP(er
->er_data_len
, sdp
->sd_jbsize
);
686 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++) {
687 struct buffer_head
*bh
;
689 int mh_size
= sizeof(struct gfs2_meta_header
);
692 error
= gfs2_alloc_blocks(ip
, &block
, &n
, 0, NULL
);
695 gfs2_trans_add_unrevoke(sdp
, block
, 1);
696 bh
= gfs2_meta_new(ip
->i_gl
, block
);
697 gfs2_trans_add_meta(ip
->i_gl
, bh
);
698 gfs2_metatype_set(bh
, GFS2_METATYPE_ED
, GFS2_FORMAT_ED
);
700 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
702 copy
= data_len
> sdp
->sd_jbsize
? sdp
->sd_jbsize
:
704 memcpy(bh
->b_data
+ mh_size
, data
, copy
);
705 if (copy
< sdp
->sd_jbsize
)
706 memset(bh
->b_data
+ mh_size
+ copy
, 0,
707 sdp
->sd_jbsize
- copy
);
709 *dataptr
++ = cpu_to_be64(bh
->b_blocknr
);
716 gfs2_assert_withdraw(sdp
, !data_len
);
722 typedef int (*ea_skeleton_call_t
) (struct gfs2_inode
*ip
,
723 struct gfs2_ea_request
*er
, void *private);
725 static int ea_alloc_skeleton(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
727 ea_skeleton_call_t skeleton_call
, void *private)
729 struct gfs2_alloc_parms ap
= { .target
= blks
};
730 struct buffer_head
*dibh
;
733 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
737 error
= gfs2_quota_lock_check(ip
, &ap
);
741 error
= gfs2_inplace_reserve(ip
, &ap
);
745 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
),
746 blks
+ gfs2_rg_blocks(ip
, blks
) +
747 RES_DINODE
+ RES_STATFS
+ RES_QUOTA
, 0);
751 error
= skeleton_call(ip
, er
, private);
755 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
757 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
758 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
759 gfs2_dinode_out(ip
, dibh
->b_data
);
764 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
766 gfs2_inplace_release(ip
);
768 gfs2_quota_unlock(ip
);
772 static int ea_init_i(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
775 struct buffer_head
*bh
;
778 error
= ea_alloc_blk(ip
, &bh
);
782 ip
->i_eattr
= bh
->b_blocknr
;
783 error
= ea_write(ip
, GFS2_EA_BH2FIRST(bh
), er
);
791 * ea_init - initializes a new eattr block
798 static int ea_init(struct gfs2_inode
*ip
, int type
, const char *name
,
799 const void *data
, size_t size
)
801 struct gfs2_ea_request er
;
802 unsigned int jbsize
= GFS2_SB(&ip
->i_inode
)->sd_jbsize
;
803 unsigned int blks
= 1;
807 er
.er_name_len
= strlen(name
);
808 er
.er_data
= (void *)data
;
809 er
.er_data_len
= size
;
811 if (GFS2_EAREQ_SIZE_STUFFED(&er
) > jbsize
)
812 blks
+= DIV_ROUND_UP(er
.er_data_len
, jbsize
);
814 return ea_alloc_skeleton(ip
, &er
, blks
, ea_init_i
, NULL
);
817 static struct gfs2_ea_header
*ea_split_ea(struct gfs2_ea_header
*ea
)
819 u32 ea_size
= GFS2_EA_SIZE(ea
);
820 struct gfs2_ea_header
*new = (struct gfs2_ea_header
*)((char *)ea
+
822 u32 new_size
= GFS2_EA_REC_LEN(ea
) - ea_size
;
823 int last
= ea
->ea_flags
& GFS2_EAFLAG_LAST
;
825 ea
->ea_rec_len
= cpu_to_be32(ea_size
);
826 ea
->ea_flags
^= last
;
828 new->ea_rec_len
= cpu_to_be32(new_size
);
829 new->ea_flags
= last
;
834 static void ea_set_remove_stuffed(struct gfs2_inode
*ip
,
835 struct gfs2_ea_location
*el
)
837 struct gfs2_ea_header
*ea
= el
->el_ea
;
838 struct gfs2_ea_header
*prev
= el
->el_prev
;
841 gfs2_trans_add_meta(ip
->i_gl
, el
->el_bh
);
843 if (!prev
|| !GFS2_EA_IS_STUFFED(ea
)) {
844 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
846 } else if (GFS2_EA2NEXT(prev
) != ea
) {
847 prev
= GFS2_EA2NEXT(prev
);
848 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
), GFS2_EA2NEXT(prev
) == ea
);
851 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
852 prev
->ea_rec_len
= cpu_to_be32(len
);
854 if (GFS2_EA_IS_LAST(ea
))
855 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
861 struct gfs2_ea_request
*es_er
;
862 struct gfs2_ea_location
*es_el
;
864 struct buffer_head
*es_bh
;
865 struct gfs2_ea_header
*es_ea
;
868 static int ea_set_simple_noalloc(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
869 struct gfs2_ea_header
*ea
, struct ea_set
*es
)
871 struct gfs2_ea_request
*er
= es
->es_er
;
872 struct buffer_head
*dibh
;
875 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ 2 * RES_EATTR
, 0);
879 gfs2_trans_add_meta(ip
->i_gl
, bh
);
882 ea
= ea_split_ea(ea
);
884 ea_write(ip
, ea
, er
);
887 ea_set_remove_stuffed(ip
, es
->es_el
);
889 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
892 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
893 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
894 gfs2_dinode_out(ip
, dibh
->b_data
);
897 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
901 static int ea_set_simple_alloc(struct gfs2_inode
*ip
,
902 struct gfs2_ea_request
*er
, void *private)
904 struct ea_set
*es
= private;
905 struct gfs2_ea_header
*ea
= es
->es_ea
;
908 gfs2_trans_add_meta(ip
->i_gl
, es
->es_bh
);
911 ea
= ea_split_ea(ea
);
913 error
= ea_write(ip
, ea
, er
);
918 ea_set_remove_stuffed(ip
, es
->es_el
);
923 static int ea_set_simple(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
924 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
927 struct ea_set
*es
= private;
932 stuffed
= ea_calc_size(GFS2_SB(&ip
->i_inode
), es
->es_er
->er_name_len
,
933 es
->es_er
->er_data_len
, &size
);
935 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
) {
936 if (GFS2_EA_REC_LEN(ea
) < size
)
938 if (!GFS2_EA_IS_STUFFED(ea
)) {
939 error
= ea_remove_unstuffed(ip
, bh
, ea
, prev
, 1);
944 } else if (GFS2_EA_REC_LEN(ea
) - GFS2_EA_SIZE(ea
) >= size
)
950 error
= ea_set_simple_noalloc(ip
, bh
, ea
, es
);
958 blks
= 2 + DIV_ROUND_UP(es
->es_er
->er_data_len
,
959 GFS2_SB(&ip
->i_inode
)->sd_jbsize
);
961 error
= ea_alloc_skeleton(ip
, es
->es_er
, blks
,
962 ea_set_simple_alloc
, es
);
970 static int ea_set_block(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
973 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
974 struct buffer_head
*indbh
, *newbh
;
977 int mh_size
= sizeof(struct gfs2_meta_header
);
979 if (ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
) {
982 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
,
987 if (gfs2_metatype_check(sdp
, indbh
, GFS2_METATYPE_IN
)) {
992 eablk
= (__be64
*)(indbh
->b_data
+ mh_size
);
993 end
= eablk
+ sdp
->sd_inptrs
;
995 for (; eablk
< end
; eablk
++)
1004 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1008 error
= gfs2_alloc_blocks(ip
, &blk
, &n
, 0, NULL
);
1011 gfs2_trans_add_unrevoke(sdp
, blk
, 1);
1012 indbh
= gfs2_meta_new(ip
->i_gl
, blk
);
1013 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1014 gfs2_metatype_set(indbh
, GFS2_METATYPE_IN
, GFS2_FORMAT_IN
);
1015 gfs2_buffer_clear_tail(indbh
, mh_size
);
1017 eablk
= (__be64
*)(indbh
->b_data
+ mh_size
);
1018 *eablk
= cpu_to_be64(ip
->i_eattr
);
1020 ip
->i_diskflags
|= GFS2_DIF_EA_INDIRECT
;
1021 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
1026 error
= ea_alloc_blk(ip
, &newbh
);
1030 *eablk
= cpu_to_be64((u64
)newbh
->b_blocknr
);
1031 error
= ea_write(ip
, GFS2_EA_BH2FIRST(newbh
), er
);
1037 ea_set_remove_stuffed(ip
, private);
1044 static int ea_set_i(struct gfs2_inode
*ip
, int type
, const char *name
,
1045 const void *value
, size_t size
, struct gfs2_ea_location
*el
)
1047 struct gfs2_ea_request er
;
1049 unsigned int blks
= 2;
1054 er
.er_data
= (void *)value
;
1055 er
.er_name_len
= strlen(name
);
1056 er
.er_data_len
= size
;
1058 memset(&es
, 0, sizeof(struct ea_set
));
1062 error
= ea_foreach(ip
, ea_set_simple
, &es
);
1068 if (!(ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
))
1070 if (GFS2_EAREQ_SIZE_STUFFED(&er
) > GFS2_SB(&ip
->i_inode
)->sd_jbsize
)
1071 blks
+= DIV_ROUND_UP(er
.er_data_len
, GFS2_SB(&ip
->i_inode
)->sd_jbsize
);
1073 return ea_alloc_skeleton(ip
, &er
, blks
, ea_set_block
, el
);
1076 static int ea_set_remove_unstuffed(struct gfs2_inode
*ip
,
1077 struct gfs2_ea_location
*el
)
1079 if (el
->el_prev
&& GFS2_EA2NEXT(el
->el_prev
) != el
->el_ea
) {
1080 el
->el_prev
= GFS2_EA2NEXT(el
->el_prev
);
1081 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
),
1082 GFS2_EA2NEXT(el
->el_prev
) == el
->el_ea
);
1085 return ea_remove_unstuffed(ip
, el
->el_bh
, el
->el_ea
, el
->el_prev
, 0);
1088 static int ea_remove_stuffed(struct gfs2_inode
*ip
, struct gfs2_ea_location
*el
)
1090 struct gfs2_ea_header
*ea
= el
->el_ea
;
1091 struct gfs2_ea_header
*prev
= el
->el_prev
;
1092 struct buffer_head
*dibh
;
1095 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ RES_EATTR
, 0);
1099 gfs2_trans_add_meta(ip
->i_gl
, el
->el_bh
);
1104 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
1105 prev
->ea_rec_len
= cpu_to_be32(len
);
1107 if (GFS2_EA_IS_LAST(ea
))
1108 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
1110 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
1113 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1115 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
1116 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
1117 gfs2_dinode_out(ip
, dibh
->b_data
);
1121 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
1127 * gfs2_xattr_remove - Remove a GFS2 extended attribute
1129 * @type: The type of the extended attribute
1130 * @name: The name of the extended attribute
1132 * This is not called directly by the VFS since we use the (common)
1133 * scheme of making a "set with NULL data" mean a remove request. Note
1134 * that this is different from a set with zero length data.
1136 * Returns: 0, or errno on failure
1139 static int gfs2_xattr_remove(struct gfs2_inode
*ip
, int type
, const char *name
)
1141 struct gfs2_ea_location el
;
1147 error
= gfs2_ea_find(ip
, type
, name
, &el
);
1153 if (GFS2_EA_IS_STUFFED(el
.el_ea
))
1154 error
= ea_remove_stuffed(ip
, &el
);
1156 error
= ea_remove_unstuffed(ip
, el
.el_bh
, el
.el_ea
, el
.el_prev
, 0);
1164 * __gfs2_xattr_set - Set (or remove) a GFS2 extended attribute
1166 * @name: The name of the extended attribute
1167 * @value: The value of the extended attribute (NULL for remove)
1168 * @size: The size of the @value argument
1169 * @flags: Create or Replace
1170 * @type: The type of the extended attribute
1172 * See gfs2_xattr_remove() for details of the removal of xattrs.
1174 * Returns: 0 or errno on failure
1177 int __gfs2_xattr_set(struct inode
*inode
, const char *name
,
1178 const void *value
, size_t size
, int flags
, int type
)
1180 struct gfs2_inode
*ip
= GFS2_I(inode
);
1181 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1182 struct gfs2_ea_location el
;
1183 unsigned int namel
= strlen(name
);
1186 if (IS_IMMUTABLE(inode
) || IS_APPEND(inode
))
1188 if (namel
> GFS2_EA_MAX_NAME_LEN
)
1192 return gfs2_xattr_remove(ip
, type
, name
);
1194 if (ea_check_size(sdp
, namel
, size
))
1198 if (flags
& XATTR_REPLACE
)
1200 return ea_init(ip
, type
, name
, value
, size
);
1203 error
= gfs2_ea_find(ip
, type
, name
, &el
);
1208 if (ip
->i_diskflags
& GFS2_DIF_APPENDONLY
) {
1214 if (!(flags
& XATTR_CREATE
)) {
1215 int unstuffed
= !GFS2_EA_IS_STUFFED(el
.el_ea
);
1216 error
= ea_set_i(ip
, type
, name
, value
, size
, &el
);
1217 if (!error
&& unstuffed
)
1218 ea_set_remove_unstuffed(ip
, &el
);
1226 if (!(flags
& XATTR_REPLACE
))
1227 error
= ea_set_i(ip
, type
, name
, value
, size
, NULL
);
1232 static int gfs2_xattr_set(const struct xattr_handler
*handler
,
1233 struct dentry
*dentry
, const char *name
,
1234 const void *value
, size_t size
, int flags
)
1236 return __gfs2_xattr_set(d_inode(dentry
), name
, value
,
1237 size
, flags
, handler
->flags
);
1241 static int ea_acl_chmod_unstuffed(struct gfs2_inode
*ip
,
1242 struct gfs2_ea_header
*ea
, char *data
)
1244 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1245 unsigned int amount
= GFS2_EA_DATA_LEN(ea
);
1246 unsigned int nptrs
= DIV_ROUND_UP(amount
, sdp
->sd_jbsize
);
1249 ret
= gfs2_trans_begin(sdp
, nptrs
+ RES_DINODE
, 0);
1253 ret
= gfs2_iter_unstuffed(ip
, ea
, data
, NULL
);
1254 gfs2_trans_end(sdp
);
1259 int gfs2_xattr_acl_chmod(struct gfs2_inode
*ip
, struct iattr
*attr
, char *data
)
1261 struct inode
*inode
= &ip
->i_inode
;
1262 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1263 struct gfs2_ea_location el
;
1266 error
= gfs2_ea_find(ip
, GFS2_EATYPE_SYS
, GFS2_POSIX_ACL_ACCESS
, &el
);
1270 if (GFS2_EA_IS_STUFFED(el
.el_ea
)) {
1271 error
= gfs2_trans_begin(sdp
, RES_DINODE
+ RES_EATTR
, 0);
1273 gfs2_trans_add_meta(ip
->i_gl
, el
.el_bh
);
1274 memcpy(GFS2_EA2DATA(el
.el_ea
), data
,
1275 GFS2_EA_DATA_LEN(el
.el_ea
));
1278 error
= ea_acl_chmod_unstuffed(ip
, el
.el_ea
, data
);
1285 error
= gfs2_setattr_simple(inode
, attr
);
1286 gfs2_trans_end(sdp
);
1290 static int ea_dealloc_indirect(struct gfs2_inode
*ip
)
1292 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1293 struct gfs2_rgrp_list rlist
;
1294 struct buffer_head
*indbh
, *dibh
;
1295 __be64
*eablk
, *end
;
1296 unsigned int rg_blocks
= 0;
1298 unsigned int blen
= 0;
1299 unsigned int blks
= 0;
1303 error
= gfs2_rindex_update(sdp
);
1307 memset(&rlist
, 0, sizeof(struct gfs2_rgrp_list
));
1309 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, &indbh
);
1313 if (gfs2_metatype_check(sdp
, indbh
, GFS2_METATYPE_IN
)) {
1318 eablk
= (__be64
*)(indbh
->b_data
+ sizeof(struct gfs2_meta_header
));
1319 end
= eablk
+ sdp
->sd_inptrs
;
1321 for (; eablk
< end
; eablk
++) {
1326 bn
= be64_to_cpu(*eablk
);
1328 if (bstart
+ blen
== bn
)
1332 gfs2_rlist_add(ip
, &rlist
, bstart
);
1339 gfs2_rlist_add(ip
, &rlist
, bstart
);
1343 gfs2_rlist_alloc(&rlist
, LM_ST_EXCLUSIVE
);
1345 for (x
= 0; x
< rlist
.rl_rgrps
; x
++) {
1346 struct gfs2_rgrpd
*rgd
;
1347 rgd
= rlist
.rl_ghs
[x
].gh_gl
->gl_object
;
1348 rg_blocks
+= rgd
->rd_length
;
1351 error
= gfs2_glock_nq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
1353 goto out_rlist_free
;
1355 error
= gfs2_trans_begin(sdp
, rg_blocks
+ RES_DINODE
+ RES_INDIRECT
+
1356 RES_STATFS
+ RES_QUOTA
, blks
);
1360 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1362 eablk
= (__be64
*)(indbh
->b_data
+ sizeof(struct gfs2_meta_header
));
1366 for (; eablk
< end
; eablk
++) {
1371 bn
= be64_to_cpu(*eablk
);
1373 if (bstart
+ blen
== bn
)
1377 gfs2_free_meta(ip
, bstart
, blen
);
1383 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
1386 gfs2_free_meta(ip
, bstart
, blen
);
1388 ip
->i_diskflags
&= ~GFS2_DIF_EA_INDIRECT
;
1390 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1392 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
1393 gfs2_dinode_out(ip
, dibh
->b_data
);
1397 gfs2_trans_end(sdp
);
1400 gfs2_glock_dq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
1402 gfs2_rlist_free(&rlist
);
1408 static int ea_dealloc_block(struct gfs2_inode
*ip
)
1410 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1411 struct gfs2_rgrpd
*rgd
;
1412 struct buffer_head
*dibh
;
1413 struct gfs2_holder gh
;
1416 error
= gfs2_rindex_update(sdp
);
1420 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_eattr
, 1);
1422 gfs2_consist_inode(ip
);
1426 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
1430 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_DINODE
+ RES_STATFS
+
1435 gfs2_free_meta(ip
, ip
->i_eattr
, 1);
1438 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
1440 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1442 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
1443 gfs2_dinode_out(ip
, dibh
->b_data
);
1447 gfs2_trans_end(sdp
);
1450 gfs2_glock_dq_uninit(&gh
);
1455 * gfs2_ea_dealloc - deallocate the extended attribute fork
1461 int gfs2_ea_dealloc(struct gfs2_inode
*ip
)
1465 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
1469 error
= gfs2_quota_hold(ip
, NO_UID_QUOTA_CHANGE
, NO_GID_QUOTA_CHANGE
);
1473 error
= ea_foreach(ip
, ea_dealloc_unstuffed
, NULL
);
1477 if (ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
) {
1478 error
= ea_dealloc_indirect(ip
);
1483 error
= ea_dealloc_block(ip
);
1486 gfs2_quota_unhold(ip
);
1490 static const struct xattr_handler gfs2_xattr_user_handler
= {
1491 .prefix
= XATTR_USER_PREFIX
,
1492 .flags
= GFS2_EATYPE_USR
,
1493 .get
= gfs2_xattr_get
,
1494 .set
= gfs2_xattr_set
,
1497 static const struct xattr_handler gfs2_xattr_security_handler
= {
1498 .prefix
= XATTR_SECURITY_PREFIX
,
1499 .flags
= GFS2_EATYPE_SECURITY
,
1500 .get
= gfs2_xattr_get
,
1501 .set
= gfs2_xattr_set
,
1504 const struct xattr_handler
*gfs2_xattr_handlers
[] = {
1505 &gfs2_xattr_user_handler
,
1506 &gfs2_xattr_security_handler
,
1507 &posix_acl_access_xattr_handler
,
1508 &posix_acl_default_xattr_handler
,