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 <asm/uaccess.h>
31 * ea_calc_size - returns the acutal number of bytes the request will take up
32 * (not counting any unstuffed data blocks)
37 * Returns: 1 if the EA should be stuffed
40 static int ea_calc_size(struct gfs2_sbd
*sdp
, unsigned int nsize
, size_t dsize
,
43 unsigned int jbsize
= sdp
->sd_jbsize
;
46 *size
= ALIGN(sizeof(struct gfs2_ea_header
) + nsize
+ dsize
, 8);
52 *size
= ALIGN(sizeof(struct gfs2_ea_header
) + nsize
+
53 (sizeof(__be64
) * DIV_ROUND_UP(dsize
, jbsize
)), 8);
58 static int ea_check_size(struct gfs2_sbd
*sdp
, unsigned int nsize
, size_t dsize
)
62 if (dsize
> GFS2_EA_MAX_DATA_LEN
)
65 ea_calc_size(sdp
, nsize
, dsize
, &size
);
67 /* This can only happen with 512 byte blocks */
68 if (size
> sdp
->sd_jbsize
)
74 typedef int (*ea_call_t
) (struct gfs2_inode
*ip
, struct buffer_head
*bh
,
75 struct gfs2_ea_header
*ea
,
76 struct gfs2_ea_header
*prev
, void *private);
78 static int ea_foreach_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
79 ea_call_t ea_call
, void *data
)
81 struct gfs2_ea_header
*ea
, *prev
= NULL
;
84 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), bh
, GFS2_METATYPE_EA
))
87 for (ea
= GFS2_EA_BH2FIRST(bh
);; prev
= ea
, ea
= GFS2_EA2NEXT(ea
)) {
88 if (!GFS2_EA_REC_LEN(ea
))
90 if (!(bh
->b_data
<= (char *)ea
&& (char *)GFS2_EA2NEXT(ea
) <=
91 bh
->b_data
+ bh
->b_size
))
93 if (!GFS2_EATYPE_VALID(ea
->ea_type
))
96 error
= ea_call(ip
, bh
, ea
, prev
, data
);
100 if (GFS2_EA_IS_LAST(ea
)) {
101 if ((char *)GFS2_EA2NEXT(ea
) !=
102 bh
->b_data
+ bh
->b_size
)
111 gfs2_consist_inode(ip
);
115 static int ea_foreach(struct gfs2_inode
*ip
, ea_call_t ea_call
, void *data
)
117 struct buffer_head
*bh
, *eabh
;
121 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, &bh
);
125 if (!(ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
)) {
126 error
= ea_foreach_i(ip
, bh
, ea_call
, data
);
130 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), bh
, GFS2_METATYPE_IN
)) {
135 eablk
= (__be64
*)(bh
->b_data
+ sizeof(struct gfs2_meta_header
));
136 end
= eablk
+ GFS2_SB(&ip
->i_inode
)->sd_inptrs
;
138 for (; eablk
< end
; eablk
++) {
143 bn
= be64_to_cpu(*eablk
);
145 error
= gfs2_meta_read(ip
->i_gl
, bn
, DIO_WAIT
, &eabh
);
148 error
= ea_foreach_i(ip
, eabh
, ea_call
, data
);
162 struct gfs2_ea_location
*ef_el
;
165 static int ea_find_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
166 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
169 struct ea_find
*ef
= private;
171 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
)
174 if (ea
->ea_type
== ef
->type
) {
175 if (ea
->ea_name_len
== ef
->namel
&&
176 !memcmp(GFS2_EA2NAME(ea
), ef
->name
, ea
->ea_name_len
)) {
177 struct gfs2_ea_location
*el
= ef
->ef_el
;
189 static int gfs2_ea_find(struct gfs2_inode
*ip
, int type
, const char *name
,
190 struct gfs2_ea_location
*el
)
197 ef
.namel
= strlen(name
);
200 memset(el
, 0, sizeof(struct gfs2_ea_location
));
202 error
= ea_foreach(ip
, ea_find_i
, &ef
);
210 * ea_dealloc_unstuffed -
217 * Take advantage of the fact that all unstuffed blocks are
218 * allocated from the same RG. But watch, this may not always
224 static int ea_dealloc_unstuffed(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
225 struct gfs2_ea_header
*ea
,
226 struct gfs2_ea_header
*prev
, void *private)
228 int *leave
= private;
229 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
230 struct gfs2_rgrpd
*rgd
;
231 struct gfs2_holder rg_gh
;
232 struct buffer_head
*dibh
;
236 unsigned int blen
= 0;
237 unsigned int blks
= 0;
241 if (GFS2_EA_IS_STUFFED(ea
))
244 dataptrs
= GFS2_EA2DATAPTRS(ea
);
245 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++, dataptrs
++) {
248 bn
= be64_to_cpu(*dataptrs
);
254 rgd
= gfs2_blk2rgrpd(sdp
, bn
);
256 gfs2_consist_inode(ip
);
260 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0, &rg_gh
);
264 error
= gfs2_trans_begin(sdp
, rgd
->rd_length
+ RES_DINODE
+
265 RES_EATTR
+ RES_STATFS
+ RES_QUOTA
, blks
);
269 gfs2_trans_add_bh(ip
->i_gl
, bh
, 1);
271 dataptrs
= GFS2_EA2DATAPTRS(ea
);
272 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++, dataptrs
++) {
275 bn
= be64_to_cpu(*dataptrs
);
277 if (bstart
+ blen
== bn
)
281 gfs2_free_meta(ip
, bstart
, blen
);
287 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
290 gfs2_free_meta(ip
, bstart
, blen
);
292 if (prev
&& !leave
) {
295 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
296 prev
->ea_rec_len
= cpu_to_be32(len
);
298 if (GFS2_EA_IS_LAST(ea
))
299 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
301 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
305 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
307 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
308 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
309 gfs2_dinode_out(ip
, dibh
->b_data
);
316 gfs2_glock_dq_uninit(&rg_gh
);
320 static int ea_remove_unstuffed(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
321 struct gfs2_ea_header
*ea
,
322 struct gfs2_ea_header
*prev
, int leave
)
324 struct gfs2_alloc
*al
;
327 al
= gfs2_alloc_get(ip
);
331 error
= gfs2_quota_hold(ip
, NO_QUOTA_CHANGE
, NO_QUOTA_CHANGE
);
335 error
= gfs2_rindex_hold(GFS2_SB(&ip
->i_inode
), &al
->al_ri_gh
);
339 error
= ea_dealloc_unstuffed(ip
, bh
, ea
, prev
, (leave
) ? &error
: NULL
);
341 gfs2_glock_dq_uninit(&al
->al_ri_gh
);
344 gfs2_quota_unhold(ip
);
351 struct gfs2_ea_request
*ei_er
;
352 unsigned int ei_size
;
355 static inline unsigned int gfs2_ea_strlen(struct gfs2_ea_header
*ea
)
357 switch (ea
->ea_type
) {
358 case GFS2_EATYPE_USR
:
359 return 5 + ea
->ea_name_len
+ 1;
360 case GFS2_EATYPE_SYS
:
361 return 7 + ea
->ea_name_len
+ 1;
362 case GFS2_EATYPE_SECURITY
:
363 return 9 + ea
->ea_name_len
+ 1;
369 static int ea_list_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
370 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
373 struct ea_list
*ei
= private;
374 struct gfs2_ea_request
*er
= ei
->ei_er
;
375 unsigned int ea_size
= gfs2_ea_strlen(ea
);
377 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
)
380 if (er
->er_data_len
) {
385 if (ei
->ei_size
+ ea_size
> er
->er_data_len
)
388 switch (ea
->ea_type
) {
389 case GFS2_EATYPE_USR
:
393 case GFS2_EATYPE_SYS
:
397 case GFS2_EATYPE_SECURITY
:
398 prefix
= "security.";
405 memcpy(er
->er_data
+ ei
->ei_size
, prefix
, l
);
406 memcpy(er
->er_data
+ ei
->ei_size
+ l
, GFS2_EA2NAME(ea
),
408 memcpy(er
->er_data
+ ei
->ei_size
+ ea_size
- 1, &c
, 1);
411 ei
->ei_size
+= ea_size
;
417 * gfs2_listxattr - List gfs2 extended attributes
418 * @dentry: The dentry whose inode we are interested in
419 * @buffer: The buffer to write the results
420 * @size: The size of the buffer
422 * Returns: actual size of data on success, -errno on error
425 ssize_t
gfs2_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
427 struct gfs2_inode
*ip
= GFS2_I(dentry
->d_inode
);
428 struct gfs2_ea_request er
;
429 struct gfs2_holder i_gh
;
432 memset(&er
, 0, sizeof(struct gfs2_ea_request
));
435 er
.er_data_len
= size
;
438 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &i_gh
);
443 struct ea_list ei
= { .ei_er
= &er
, .ei_size
= 0 };
445 error
= ea_foreach(ip
, ea_list_i
, &ei
);
450 gfs2_glock_dq_uninit(&i_gh
);
456 * ea_get_unstuffed - actually copies the unstuffed data into the
458 * @ip: The GFS2 inode
459 * @ea: The extended attribute header structure
460 * @data: The data to be copied
465 static int ea_get_unstuffed(struct gfs2_inode
*ip
, struct gfs2_ea_header
*ea
,
468 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
469 struct buffer_head
**bh
;
470 unsigned int amount
= GFS2_EA_DATA_LEN(ea
);
471 unsigned int nptrs
= DIV_ROUND_UP(amount
, sdp
->sd_jbsize
);
472 __be64
*dataptrs
= GFS2_EA2DATAPTRS(ea
);
476 bh
= kcalloc(nptrs
, sizeof(struct buffer_head
*), GFP_NOFS
);
480 for (x
= 0; x
< nptrs
; x
++) {
481 error
= gfs2_meta_read(ip
->i_gl
, be64_to_cpu(*dataptrs
), 0,
491 for (x
= 0; x
< nptrs
; x
++) {
492 error
= gfs2_meta_wait(sdp
, bh
[x
]);
494 for (; x
< nptrs
; x
++)
498 if (gfs2_metatype_check(sdp
, bh
[x
], GFS2_METATYPE_ED
)) {
499 for (; x
< nptrs
; x
++)
505 memcpy(data
, bh
[x
]->b_data
+ sizeof(struct gfs2_meta_header
),
506 (sdp
->sd_jbsize
> amount
) ? amount
: sdp
->sd_jbsize
);
508 amount
-= sdp
->sd_jbsize
;
509 data
+= sdp
->sd_jbsize
;
519 static int gfs2_ea_get_copy(struct gfs2_inode
*ip
, struct gfs2_ea_location
*el
,
520 char *data
, size_t size
)
523 size_t len
= GFS2_EA_DATA_LEN(el
->el_ea
);
527 if (GFS2_EA_IS_STUFFED(el
->el_ea
)) {
528 memcpy(data
, GFS2_EA2DATA(el
->el_ea
), len
);
531 ret
= ea_get_unstuffed(ip
, el
->el_ea
, data
);
537 int gfs2_xattr_acl_get(struct gfs2_inode
*ip
, const char *name
, char **ppdata
)
539 struct gfs2_ea_location el
;
544 error
= gfs2_ea_find(ip
, GFS2_EATYPE_SYS
, name
, &el
);
549 if (!GFS2_EA_DATA_LEN(el
.el_ea
))
552 len
= GFS2_EA_DATA_LEN(el
.el_ea
);
553 data
= kmalloc(len
, GFP_NOFS
);
558 error
= gfs2_ea_get_copy(ip
, &el
, data
, len
);
568 * gfs2_xattr_get - Get a GFS2 extended attribute
570 * @type: The type of extended attribute
571 * @name: The name of the extended attribute
572 * @buffer: The buffer to write the result into
573 * @size: The size of the buffer
575 * Returns: actual size of data on success, -errno on error
578 int gfs2_xattr_get(struct inode
*inode
, int type
, const char *name
,
579 void *buffer
, size_t size
)
581 struct gfs2_inode
*ip
= GFS2_I(inode
);
582 struct gfs2_ea_location el
;
587 if (strlen(name
) > GFS2_EA_MAX_NAME_LEN
)
590 error
= gfs2_ea_find(ip
, type
, name
, &el
);
596 error
= gfs2_ea_get_copy(ip
, &el
, buffer
, size
);
598 error
= GFS2_EA_DATA_LEN(el
.el_ea
);
605 * ea_alloc_blk - allocates a new block for extended attributes.
606 * @ip: A pointer to the inode that's getting extended attributes
607 * @bhp: Pointer to pointer to a struct buffer_head
612 static int ea_alloc_blk(struct gfs2_inode
*ip
, struct buffer_head
**bhp
)
614 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
615 struct gfs2_ea_header
*ea
;
620 error
= gfs2_alloc_block(ip
, &block
, &n
);
623 gfs2_trans_add_unrevoke(sdp
, block
, 1);
624 *bhp
= gfs2_meta_new(ip
->i_gl
, block
);
625 gfs2_trans_add_bh(ip
->i_gl
, *bhp
, 1);
626 gfs2_metatype_set(*bhp
, GFS2_METATYPE_EA
, GFS2_FORMAT_EA
);
627 gfs2_buffer_clear_tail(*bhp
, sizeof(struct gfs2_meta_header
));
629 ea
= GFS2_EA_BH2FIRST(*bhp
);
630 ea
->ea_rec_len
= cpu_to_be32(sdp
->sd_jbsize
);
631 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
632 ea
->ea_flags
= GFS2_EAFLAG_LAST
;
635 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
641 * ea_write - writes the request info to an ea, creating new blocks if
643 * @ip: inode that is being modified
644 * @ea: the location of the new ea in a block
645 * @er: the write request
647 * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
652 static int ea_write(struct gfs2_inode
*ip
, struct gfs2_ea_header
*ea
,
653 struct gfs2_ea_request
*er
)
655 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
658 ea
->ea_data_len
= cpu_to_be32(er
->er_data_len
);
659 ea
->ea_name_len
= er
->er_name_len
;
660 ea
->ea_type
= er
->er_type
;
663 memcpy(GFS2_EA2NAME(ea
), er
->er_name
, er
->er_name_len
);
665 if (GFS2_EAREQ_SIZE_STUFFED(er
) <= sdp
->sd_jbsize
) {
667 memcpy(GFS2_EA2DATA(ea
), er
->er_data
, er
->er_data_len
);
669 __be64
*dataptr
= GFS2_EA2DATAPTRS(ea
);
670 const char *data
= er
->er_data
;
671 unsigned int data_len
= er
->er_data_len
;
675 ea
->ea_num_ptrs
= DIV_ROUND_UP(er
->er_data_len
, sdp
->sd_jbsize
);
676 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++) {
677 struct buffer_head
*bh
;
679 int mh_size
= sizeof(struct gfs2_meta_header
);
682 error
= gfs2_alloc_block(ip
, &block
, &n
);
685 gfs2_trans_add_unrevoke(sdp
, block
, 1);
686 bh
= gfs2_meta_new(ip
->i_gl
, block
);
687 gfs2_trans_add_bh(ip
->i_gl
, bh
, 1);
688 gfs2_metatype_set(bh
, GFS2_METATYPE_ED
, GFS2_FORMAT_ED
);
690 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
692 copy
= data_len
> sdp
->sd_jbsize
? sdp
->sd_jbsize
:
694 memcpy(bh
->b_data
+ mh_size
, data
, copy
);
695 if (copy
< sdp
->sd_jbsize
)
696 memset(bh
->b_data
+ mh_size
+ copy
, 0,
697 sdp
->sd_jbsize
- copy
);
699 *dataptr
++ = cpu_to_be64(bh
->b_blocknr
);
706 gfs2_assert_withdraw(sdp
, !data_len
);
712 typedef int (*ea_skeleton_call_t
) (struct gfs2_inode
*ip
,
713 struct gfs2_ea_request
*er
, void *private);
715 static int ea_alloc_skeleton(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
717 ea_skeleton_call_t skeleton_call
, void *private)
719 struct gfs2_alloc
*al
;
720 struct buffer_head
*dibh
;
723 al
= gfs2_alloc_get(ip
);
727 error
= gfs2_quota_lock_check(ip
);
731 al
->al_requested
= blks
;
733 error
= gfs2_inplace_reserve(ip
);
737 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
),
738 blks
+ al
->al_rgd
->rd_length
+
739 RES_DINODE
+ RES_STATFS
+ RES_QUOTA
, 0);
743 error
= skeleton_call(ip
, er
, private);
747 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
749 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
750 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
751 gfs2_dinode_out(ip
, dibh
->b_data
);
756 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
758 gfs2_inplace_release(ip
);
760 gfs2_quota_unlock(ip
);
766 static int ea_init_i(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
769 struct buffer_head
*bh
;
772 error
= ea_alloc_blk(ip
, &bh
);
776 ip
->i_eattr
= bh
->b_blocknr
;
777 error
= ea_write(ip
, GFS2_EA_BH2FIRST(bh
), er
);
785 * ea_init - initializes a new eattr block
792 static int ea_init(struct gfs2_inode
*ip
, int type
, const char *name
,
793 const void *data
, size_t size
)
795 struct gfs2_ea_request er
;
796 unsigned int jbsize
= GFS2_SB(&ip
->i_inode
)->sd_jbsize
;
797 unsigned int blks
= 1;
801 er
.er_name_len
= strlen(name
);
802 er
.er_data
= (void *)data
;
803 er
.er_data_len
= size
;
805 if (GFS2_EAREQ_SIZE_STUFFED(&er
) > jbsize
)
806 blks
+= DIV_ROUND_UP(er
.er_data_len
, jbsize
);
808 return ea_alloc_skeleton(ip
, &er
, blks
, ea_init_i
, NULL
);
811 static struct gfs2_ea_header
*ea_split_ea(struct gfs2_ea_header
*ea
)
813 u32 ea_size
= GFS2_EA_SIZE(ea
);
814 struct gfs2_ea_header
*new = (struct gfs2_ea_header
*)((char *)ea
+
816 u32 new_size
= GFS2_EA_REC_LEN(ea
) - ea_size
;
817 int last
= ea
->ea_flags
& GFS2_EAFLAG_LAST
;
819 ea
->ea_rec_len
= cpu_to_be32(ea_size
);
820 ea
->ea_flags
^= last
;
822 new->ea_rec_len
= cpu_to_be32(new_size
);
823 new->ea_flags
= last
;
828 static void ea_set_remove_stuffed(struct gfs2_inode
*ip
,
829 struct gfs2_ea_location
*el
)
831 struct gfs2_ea_header
*ea
= el
->el_ea
;
832 struct gfs2_ea_header
*prev
= el
->el_prev
;
835 gfs2_trans_add_bh(ip
->i_gl
, el
->el_bh
, 1);
837 if (!prev
|| !GFS2_EA_IS_STUFFED(ea
)) {
838 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
840 } else if (GFS2_EA2NEXT(prev
) != ea
) {
841 prev
= GFS2_EA2NEXT(prev
);
842 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
), GFS2_EA2NEXT(prev
) == ea
);
845 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
846 prev
->ea_rec_len
= cpu_to_be32(len
);
848 if (GFS2_EA_IS_LAST(ea
))
849 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
855 struct gfs2_ea_request
*es_er
;
856 struct gfs2_ea_location
*es_el
;
858 struct buffer_head
*es_bh
;
859 struct gfs2_ea_header
*es_ea
;
862 static int ea_set_simple_noalloc(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
863 struct gfs2_ea_header
*ea
, struct ea_set
*es
)
865 struct gfs2_ea_request
*er
= es
->es_er
;
866 struct buffer_head
*dibh
;
869 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ 2 * RES_EATTR
, 0);
873 gfs2_trans_add_bh(ip
->i_gl
, bh
, 1);
876 ea
= ea_split_ea(ea
);
878 ea_write(ip
, ea
, er
);
881 ea_set_remove_stuffed(ip
, es
->es_el
);
883 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
886 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
887 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
888 gfs2_dinode_out(ip
, dibh
->b_data
);
891 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
895 static int ea_set_simple_alloc(struct gfs2_inode
*ip
,
896 struct gfs2_ea_request
*er
, void *private)
898 struct ea_set
*es
= private;
899 struct gfs2_ea_header
*ea
= es
->es_ea
;
902 gfs2_trans_add_bh(ip
->i_gl
, es
->es_bh
, 1);
905 ea
= ea_split_ea(ea
);
907 error
= ea_write(ip
, ea
, er
);
912 ea_set_remove_stuffed(ip
, es
->es_el
);
917 static int ea_set_simple(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
918 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
921 struct ea_set
*es
= private;
926 stuffed
= ea_calc_size(GFS2_SB(&ip
->i_inode
), es
->es_er
->er_name_len
,
927 es
->es_er
->er_data_len
, &size
);
929 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
) {
930 if (GFS2_EA_REC_LEN(ea
) < size
)
932 if (!GFS2_EA_IS_STUFFED(ea
)) {
933 error
= ea_remove_unstuffed(ip
, bh
, ea
, prev
, 1);
938 } else if (GFS2_EA_REC_LEN(ea
) - GFS2_EA_SIZE(ea
) >= size
)
944 error
= ea_set_simple_noalloc(ip
, bh
, ea
, es
);
952 blks
= 2 + DIV_ROUND_UP(es
->es_er
->er_data_len
,
953 GFS2_SB(&ip
->i_inode
)->sd_jbsize
);
955 error
= ea_alloc_skeleton(ip
, es
->es_er
, blks
,
956 ea_set_simple_alloc
, es
);
964 static int ea_set_block(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
967 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
968 struct buffer_head
*indbh
, *newbh
;
971 int mh_size
= sizeof(struct gfs2_meta_header
);
973 if (ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
) {
976 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
,
981 if (gfs2_metatype_check(sdp
, indbh
, GFS2_METATYPE_IN
)) {
986 eablk
= (__be64
*)(indbh
->b_data
+ mh_size
);
987 end
= eablk
+ sdp
->sd_inptrs
;
989 for (; eablk
< end
; eablk
++)
998 gfs2_trans_add_bh(ip
->i_gl
, indbh
, 1);
1002 error
= gfs2_alloc_block(ip
, &blk
, &n
);
1005 gfs2_trans_add_unrevoke(sdp
, blk
, 1);
1006 indbh
= gfs2_meta_new(ip
->i_gl
, blk
);
1007 gfs2_trans_add_bh(ip
->i_gl
, indbh
, 1);
1008 gfs2_metatype_set(indbh
, GFS2_METATYPE_IN
, GFS2_FORMAT_IN
);
1009 gfs2_buffer_clear_tail(indbh
, mh_size
);
1011 eablk
= (__be64
*)(indbh
->b_data
+ mh_size
);
1012 *eablk
= cpu_to_be64(ip
->i_eattr
);
1014 ip
->i_diskflags
|= GFS2_DIF_EA_INDIRECT
;
1015 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
1020 error
= ea_alloc_blk(ip
, &newbh
);
1024 *eablk
= cpu_to_be64((u64
)newbh
->b_blocknr
);
1025 error
= ea_write(ip
, GFS2_EA_BH2FIRST(newbh
), er
);
1031 ea_set_remove_stuffed(ip
, private);
1038 static int ea_set_i(struct gfs2_inode
*ip
, int type
, const char *name
,
1039 const void *value
, size_t size
, struct gfs2_ea_location
*el
)
1041 struct gfs2_ea_request er
;
1043 unsigned int blks
= 2;
1048 er
.er_data
= (void *)value
;
1049 er
.er_name_len
= strlen(name
);
1050 er
.er_data_len
= size
;
1052 memset(&es
, 0, sizeof(struct ea_set
));
1056 error
= ea_foreach(ip
, ea_set_simple
, &es
);
1062 if (!(ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
))
1064 if (GFS2_EAREQ_SIZE_STUFFED(&er
) > GFS2_SB(&ip
->i_inode
)->sd_jbsize
)
1065 blks
+= DIV_ROUND_UP(er
.er_data_len
, GFS2_SB(&ip
->i_inode
)->sd_jbsize
);
1067 return ea_alloc_skeleton(ip
, &er
, blks
, ea_set_block
, el
);
1070 static int ea_set_remove_unstuffed(struct gfs2_inode
*ip
,
1071 struct gfs2_ea_location
*el
)
1073 if (el
->el_prev
&& GFS2_EA2NEXT(el
->el_prev
) != el
->el_ea
) {
1074 el
->el_prev
= GFS2_EA2NEXT(el
->el_prev
);
1075 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
),
1076 GFS2_EA2NEXT(el
->el_prev
) == el
->el_ea
);
1079 return ea_remove_unstuffed(ip
, el
->el_bh
, el
->el_ea
, el
->el_prev
, 0);
1082 static int ea_remove_stuffed(struct gfs2_inode
*ip
, struct gfs2_ea_location
*el
)
1084 struct gfs2_ea_header
*ea
= el
->el_ea
;
1085 struct gfs2_ea_header
*prev
= el
->el_prev
;
1086 struct buffer_head
*dibh
;
1089 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ RES_EATTR
, 0);
1093 gfs2_trans_add_bh(ip
->i_gl
, el
->el_bh
, 1);
1098 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
1099 prev
->ea_rec_len
= cpu_to_be32(len
);
1101 if (GFS2_EA_IS_LAST(ea
))
1102 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
1104 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
1107 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1109 ip
->i_inode
.i_ctime
= CURRENT_TIME
;
1110 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1111 gfs2_dinode_out(ip
, dibh
->b_data
);
1115 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
1121 * gfs2_xattr_remove - Remove a GFS2 extended attribute
1123 * @type: The type of the extended attribute
1124 * @name: The name of the extended attribute
1126 * This is not called directly by the VFS since we use the (common)
1127 * scheme of making a "set with NULL data" mean a remove request. Note
1128 * that this is different from a set with zero length data.
1130 * Returns: 0, or errno on failure
1133 static int gfs2_xattr_remove(struct inode
*inode
, int type
, const char *name
)
1135 struct gfs2_inode
*ip
= GFS2_I(inode
);
1136 struct gfs2_ea_location el
;
1142 error
= gfs2_ea_find(ip
, type
, name
, &el
);
1148 if (GFS2_EA_IS_STUFFED(el
.el_ea
))
1149 error
= ea_remove_stuffed(ip
, &el
);
1151 error
= ea_remove_unstuffed(ip
, el
.el_bh
, el
.el_ea
, el
.el_prev
, 0);
1159 * gfs2_xattr_set - Set (or remove) a GFS2 extended attribute
1161 * @type: The type of the extended attribute
1162 * @name: The name of the extended attribute
1163 * @value: The value of the extended attribute (NULL for remove)
1164 * @size: The size of the @value argument
1165 * @flags: Create or Replace
1167 * See gfs2_xattr_remove() for details of the removal of xattrs.
1169 * Returns: 0 or errno on failure
1172 int gfs2_xattr_set(struct inode
*inode
, int type
, const char *name
,
1173 const void *value
, size_t size
, int flags
)
1175 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1176 struct gfs2_inode
*ip
= GFS2_I(inode
);
1177 struct gfs2_ea_location el
;
1178 unsigned int namel
= strlen(name
);
1181 if (IS_IMMUTABLE(inode
) || IS_APPEND(inode
))
1183 if (namel
> GFS2_EA_MAX_NAME_LEN
)
1187 return gfs2_xattr_remove(inode
, type
, name
);
1189 if (ea_check_size(sdp
, namel
, size
))
1193 if (flags
& XATTR_REPLACE
)
1195 return ea_init(ip
, type
, name
, value
, size
);
1198 error
= gfs2_ea_find(ip
, type
, name
, &el
);
1203 if (ip
->i_diskflags
& GFS2_DIF_APPENDONLY
) {
1209 if (!(flags
& XATTR_CREATE
)) {
1210 int unstuffed
= !GFS2_EA_IS_STUFFED(el
.el_ea
);
1211 error
= ea_set_i(ip
, type
, name
, value
, size
, &el
);
1212 if (!error
&& unstuffed
)
1213 ea_set_remove_unstuffed(ip
, &el
);
1221 if (!(flags
& XATTR_REPLACE
))
1222 error
= ea_set_i(ip
, type
, name
, value
, size
, NULL
);
1227 static int ea_acl_chmod_unstuffed(struct gfs2_inode
*ip
,
1228 struct gfs2_ea_header
*ea
, char *data
)
1230 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1231 struct buffer_head
**bh
;
1232 unsigned int amount
= GFS2_EA_DATA_LEN(ea
);
1233 unsigned int nptrs
= DIV_ROUND_UP(amount
, sdp
->sd_jbsize
);
1234 __be64
*dataptrs
= GFS2_EA2DATAPTRS(ea
);
1238 bh
= kcalloc(nptrs
, sizeof(struct buffer_head
*), GFP_NOFS
);
1242 error
= gfs2_trans_begin(sdp
, nptrs
+ RES_DINODE
, 0);
1246 for (x
= 0; x
< nptrs
; x
++) {
1247 error
= gfs2_meta_read(ip
->i_gl
, be64_to_cpu(*dataptrs
), 0,
1257 for (x
= 0; x
< nptrs
; x
++) {
1258 error
= gfs2_meta_wait(sdp
, bh
[x
]);
1260 for (; x
< nptrs
; x
++)
1264 if (gfs2_metatype_check(sdp
, bh
[x
], GFS2_METATYPE_ED
)) {
1265 for (; x
< nptrs
; x
++)
1271 gfs2_trans_add_bh(ip
->i_gl
, bh
[x
], 1);
1273 memcpy(bh
[x
]->b_data
+ sizeof(struct gfs2_meta_header
), data
,
1274 (sdp
->sd_jbsize
> amount
) ? amount
: sdp
->sd_jbsize
);
1276 amount
-= sdp
->sd_jbsize
;
1277 data
+= sdp
->sd_jbsize
;
1287 gfs2_trans_end(sdp
);
1292 int gfs2_xattr_acl_chmod(struct gfs2_inode
*ip
, struct iattr
*attr
, char *data
)
1294 struct gfs2_ea_location el
;
1295 struct buffer_head
*dibh
;
1298 error
= gfs2_ea_find(ip
, GFS2_EATYPE_SYS
, GFS2_POSIX_ACL_ACCESS
, &el
);
1302 if (GFS2_EA_IS_STUFFED(el
.el_ea
)) {
1303 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ RES_EATTR
, 0);
1307 gfs2_trans_add_bh(ip
->i_gl
, el
.el_bh
, 1);
1308 memcpy(GFS2_EA2DATA(el
.el_ea
), data
,
1309 GFS2_EA_DATA_LEN(el
.el_ea
));
1311 error
= ea_acl_chmod_unstuffed(ip
, el
.el_ea
, data
);
1316 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1318 error
= inode_setattr(&ip
->i_inode
, attr
);
1319 gfs2_assert_warn(GFS2_SB(&ip
->i_inode
), !error
);
1320 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1321 gfs2_dinode_out(ip
, dibh
->b_data
);
1325 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
1330 static int ea_dealloc_indirect(struct gfs2_inode
*ip
)
1332 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1333 struct gfs2_rgrp_list rlist
;
1334 struct buffer_head
*indbh
, *dibh
;
1335 __be64
*eablk
, *end
;
1336 unsigned int rg_blocks
= 0;
1338 unsigned int blen
= 0;
1339 unsigned int blks
= 0;
1343 memset(&rlist
, 0, sizeof(struct gfs2_rgrp_list
));
1345 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, &indbh
);
1349 if (gfs2_metatype_check(sdp
, indbh
, GFS2_METATYPE_IN
)) {
1354 eablk
= (__be64
*)(indbh
->b_data
+ sizeof(struct gfs2_meta_header
));
1355 end
= eablk
+ sdp
->sd_inptrs
;
1357 for (; eablk
< end
; eablk
++) {
1362 bn
= be64_to_cpu(*eablk
);
1364 if (bstart
+ blen
== bn
)
1368 gfs2_rlist_add(sdp
, &rlist
, bstart
);
1375 gfs2_rlist_add(sdp
, &rlist
, bstart
);
1379 gfs2_rlist_alloc(&rlist
, LM_ST_EXCLUSIVE
);
1381 for (x
= 0; x
< rlist
.rl_rgrps
; x
++) {
1382 struct gfs2_rgrpd
*rgd
;
1383 rgd
= rlist
.rl_ghs
[x
].gh_gl
->gl_object
;
1384 rg_blocks
+= rgd
->rd_length
;
1387 error
= gfs2_glock_nq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
1389 goto out_rlist_free
;
1391 error
= gfs2_trans_begin(sdp
, rg_blocks
+ RES_DINODE
+ RES_INDIRECT
+
1392 RES_STATFS
+ RES_QUOTA
, blks
);
1396 gfs2_trans_add_bh(ip
->i_gl
, indbh
, 1);
1398 eablk
= (__be64
*)(indbh
->b_data
+ sizeof(struct gfs2_meta_header
));
1402 for (; eablk
< end
; eablk
++) {
1407 bn
= be64_to_cpu(*eablk
);
1409 if (bstart
+ blen
== bn
)
1413 gfs2_free_meta(ip
, bstart
, blen
);
1419 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
1422 gfs2_free_meta(ip
, bstart
, blen
);
1424 ip
->i_diskflags
&= ~GFS2_DIF_EA_INDIRECT
;
1426 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1428 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1429 gfs2_dinode_out(ip
, dibh
->b_data
);
1433 gfs2_trans_end(sdp
);
1436 gfs2_glock_dq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
1438 gfs2_rlist_free(&rlist
);
1444 static int ea_dealloc_block(struct gfs2_inode
*ip
)
1446 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1447 struct gfs2_alloc
*al
= ip
->i_alloc
;
1448 struct gfs2_rgrpd
*rgd
;
1449 struct buffer_head
*dibh
;
1452 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_eattr
);
1454 gfs2_consist_inode(ip
);
1458 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0,
1463 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_DINODE
+ RES_STATFS
+
1468 gfs2_free_meta(ip
, ip
->i_eattr
, 1);
1471 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
1473 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1475 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1476 gfs2_dinode_out(ip
, dibh
->b_data
);
1480 gfs2_trans_end(sdp
);
1483 gfs2_glock_dq_uninit(&al
->al_rgd_gh
);
1488 * gfs2_ea_dealloc - deallocate the extended attribute fork
1494 int gfs2_ea_dealloc(struct gfs2_inode
*ip
)
1496 struct gfs2_alloc
*al
;
1499 al
= gfs2_alloc_get(ip
);
1503 error
= gfs2_quota_hold(ip
, NO_QUOTA_CHANGE
, NO_QUOTA_CHANGE
);
1507 error
= gfs2_rindex_hold(GFS2_SB(&ip
->i_inode
), &al
->al_ri_gh
);
1511 error
= ea_foreach(ip
, ea_dealloc_unstuffed
, NULL
);
1515 if (ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
) {
1516 error
= ea_dealloc_indirect(ip
);
1521 error
= ea_dealloc_block(ip
);
1524 gfs2_glock_dq_uninit(&al
->al_ri_gh
);
1526 gfs2_quota_unhold(ip
);
1532 static int gfs2_xattr_user_get(struct inode
*inode
, const char *name
,
1533 void *buffer
, size_t size
)
1535 return gfs2_xattr_get(inode
, GFS2_EATYPE_USR
, name
, buffer
, size
);
1538 static int gfs2_xattr_user_set(struct inode
*inode
, const char *name
,
1539 const void *value
, size_t size
, int flags
)
1541 return gfs2_xattr_set(inode
, GFS2_EATYPE_USR
, name
, value
, size
, flags
);
1544 static int gfs2_xattr_security_get(struct inode
*inode
, const char *name
,
1545 void *buffer
, size_t size
)
1547 return gfs2_xattr_get(inode
, GFS2_EATYPE_SECURITY
, name
, buffer
, size
);
1550 static int gfs2_xattr_security_set(struct inode
*inode
, const char *name
,
1551 const void *value
, size_t size
, int flags
)
1553 return gfs2_xattr_set(inode
, GFS2_EATYPE_SECURITY
, name
, value
, size
, flags
);
1556 static struct xattr_handler gfs2_xattr_user_handler
= {
1557 .prefix
= XATTR_USER_PREFIX
,
1558 .get
= gfs2_xattr_user_get
,
1559 .set
= gfs2_xattr_user_set
,
1562 static struct xattr_handler gfs2_xattr_security_handler
= {
1563 .prefix
= XATTR_SECURITY_PREFIX
,
1564 .get
= gfs2_xattr_security_get
,
1565 .set
= gfs2_xattr_security_set
,
1568 struct xattr_handler
*gfs2_xattr_handlers
[] = {
1569 &gfs2_xattr_user_handler
,
1570 &gfs2_xattr_security_handler
,
1571 &gfs2_xattr_system_handler
,