1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
7 #include <linux/slab.h>
8 #include <linux/spinlock.h>
9 #include <linux/completion.h>
10 #include <linux/buffer_head.h>
11 #include <linux/xattr.h>
12 #include <linux/gfs2_ondisk.h>
13 #include <linux/posix_acl_xattr.h>
14 #include <linux/uaccess.h>
30 * ea_calc_size - returns the actual number of bytes the request will take up
31 * (not counting any unstuffed data blocks)
33 * Returns: 1 if the EA should be stuffed
36 static int ea_calc_size(struct gfs2_sbd
*sdp
, unsigned int nsize
, size_t dsize
,
39 unsigned int jbsize
= sdp
->sd_jbsize
;
42 *size
= ALIGN(sizeof(struct gfs2_ea_header
) + nsize
+ dsize
, 8);
48 *size
= ALIGN(sizeof(struct gfs2_ea_header
) + nsize
+
49 (sizeof(__be64
) * DIV_ROUND_UP(dsize
, jbsize
)), 8);
54 static int ea_check_size(struct gfs2_sbd
*sdp
, unsigned int nsize
, size_t dsize
)
58 if (dsize
> GFS2_EA_MAX_DATA_LEN
)
61 ea_calc_size(sdp
, nsize
, dsize
, &size
);
63 /* This can only happen with 512 byte blocks */
64 if (size
> sdp
->sd_jbsize
)
70 static bool gfs2_eatype_valid(struct gfs2_sbd
*sdp
, u8 type
)
72 switch(sdp
->sd_sb
.sb_fs_format
) {
73 case GFS2_FS_FORMAT_MAX
:
76 case GFS2_FS_FORMAT_MIN
:
77 return type
<= GFS2_EATYPE_SECURITY
;
84 typedef int (*ea_call_t
) (struct gfs2_inode
*ip
, struct buffer_head
*bh
,
85 struct gfs2_ea_header
*ea
,
86 struct gfs2_ea_header
*prev
, void *private);
88 static int ea_foreach_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
89 ea_call_t ea_call
, void *data
)
91 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
92 struct gfs2_ea_header
*ea
, *prev
= NULL
;
95 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), bh
, GFS2_METATYPE_EA
))
98 for (ea
= GFS2_EA_BH2FIRST(bh
);; prev
= ea
, ea
= GFS2_EA2NEXT(ea
)) {
99 if (!GFS2_EA_REC_LEN(ea
))
101 if (!(bh
->b_data
<= (char *)ea
&& (char *)GFS2_EA2NEXT(ea
) <=
102 bh
->b_data
+ bh
->b_size
))
104 if (!gfs2_eatype_valid(sdp
, ea
->ea_type
))
106 error
= ea_call(ip
, bh
, ea
, prev
, data
);
110 if (GFS2_EA_IS_LAST(ea
)) {
111 if ((char *)GFS2_EA2NEXT(ea
) !=
112 bh
->b_data
+ bh
->b_size
)
121 gfs2_consist_inode(ip
);
125 static int ea_foreach(struct gfs2_inode
*ip
, ea_call_t ea_call
, void *data
)
127 struct buffer_head
*bh
, *eabh
;
131 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, 0, &bh
);
135 if (!(ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
)) {
136 error
= ea_foreach_i(ip
, bh
, ea_call
, data
);
140 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), bh
, GFS2_METATYPE_IN
)) {
145 eablk
= (__be64
*)(bh
->b_data
+ sizeof(struct gfs2_meta_header
));
146 end
= eablk
+ GFS2_SB(&ip
->i_inode
)->sd_inptrs
;
148 for (; eablk
< end
; eablk
++) {
153 bn
= be64_to_cpu(*eablk
);
155 error
= gfs2_meta_read(ip
->i_gl
, bn
, DIO_WAIT
, 0, &eabh
);
158 error
= ea_foreach_i(ip
, eabh
, ea_call
, data
);
172 struct gfs2_ea_location
*ef_el
;
175 static int ea_find_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
176 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
179 struct ea_find
*ef
= private;
181 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
)
184 if (ea
->ea_type
== ef
->type
) {
185 if (ea
->ea_name_len
== ef
->namel
&&
186 !memcmp(GFS2_EA2NAME(ea
), ef
->name
, ea
->ea_name_len
)) {
187 struct gfs2_ea_location
*el
= ef
->ef_el
;
199 static int gfs2_ea_find(struct gfs2_inode
*ip
, int type
, const char *name
,
200 struct gfs2_ea_location
*el
)
207 ef
.namel
= strlen(name
);
210 memset(el
, 0, sizeof(struct gfs2_ea_location
));
212 error
= ea_foreach(ip
, ea_find_i
, &ef
);
220 * ea_dealloc_unstuffed
222 * Take advantage of the fact that all unstuffed blocks are
223 * allocated from the same RG. But watch, this may not always
229 static int ea_dealloc_unstuffed(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
230 struct gfs2_ea_header
*ea
,
231 struct gfs2_ea_header
*prev
, void *private)
233 int *leave
= private;
234 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
235 struct gfs2_rgrpd
*rgd
;
236 struct gfs2_holder rg_gh
;
240 unsigned int blen
= 0;
241 unsigned int blks
= 0;
245 error
= gfs2_rindex_update(sdp
);
249 if (GFS2_EA_IS_STUFFED(ea
))
252 dataptrs
= GFS2_EA2DATAPTRS(ea
);
253 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++, dataptrs
++) {
256 bn
= be64_to_cpu(*dataptrs
);
262 rgd
= gfs2_blk2rgrpd(sdp
, bn
, 1);
264 gfs2_consist_inode(ip
);
268 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
,
269 LM_FLAG_NODE_SCOPE
, &rg_gh
);
273 error
= gfs2_trans_begin(sdp
, rgd
->rd_length
+ RES_DINODE
+
274 RES_EATTR
+ RES_STATFS
+ RES_QUOTA
, blks
);
278 gfs2_trans_add_meta(ip
->i_gl
, bh
);
280 dataptrs
= GFS2_EA2DATAPTRS(ea
);
281 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++, dataptrs
++) {
284 bn
= be64_to_cpu(*dataptrs
);
286 if (bstart
+ blen
== bn
)
290 gfs2_free_meta(ip
, rgd
, bstart
, blen
);
296 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
299 gfs2_free_meta(ip
, rgd
, bstart
, blen
);
301 if (prev
&& !leave
) {
304 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
305 prev
->ea_rec_len
= cpu_to_be32(len
);
307 if (GFS2_EA_IS_LAST(ea
))
308 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
310 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
314 ip
->i_inode
.i_ctime
= current_time(&ip
->i_inode
);
315 __mark_inode_dirty(&ip
->i_inode
, I_DIRTY_DATASYNC
);
320 gfs2_glock_dq_uninit(&rg_gh
);
324 static int ea_remove_unstuffed(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
325 struct gfs2_ea_header
*ea
,
326 struct gfs2_ea_header
*prev
, int leave
)
330 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
334 error
= gfs2_quota_hold(ip
, NO_UID_QUOTA_CHANGE
, NO_GID_QUOTA_CHANGE
);
338 error
= ea_dealloc_unstuffed(ip
, bh
, ea
, prev
, (leave
) ? &error
: NULL
);
340 gfs2_quota_unhold(ip
);
346 struct gfs2_ea_request
*ei_er
;
347 unsigned int ei_size
;
350 static int ea_list_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
351 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
354 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
355 struct ea_list
*ei
= private;
356 struct gfs2_ea_request
*er
= ei
->ei_er
;
357 unsigned int ea_size
;
361 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
)
364 BUG_ON(ea
->ea_type
> GFS2_EATYPE_SECURITY
&&
365 sdp
->sd_sb
.sb_fs_format
== GFS2_FS_FORMAT_MIN
);
366 switch (ea
->ea_type
) {
367 case GFS2_EATYPE_USR
:
371 case GFS2_EATYPE_SYS
:
375 case GFS2_EATYPE_SECURITY
:
376 prefix
= "security.";
379 case GFS2_EATYPE_TRUSTED
:
387 ea_size
= l
+ ea
->ea_name_len
+ 1;
388 if (er
->er_data_len
) {
389 if (ei
->ei_size
+ ea_size
> er
->er_data_len
)
392 memcpy(er
->er_data
+ ei
->ei_size
, prefix
, l
);
393 memcpy(er
->er_data
+ ei
->ei_size
+ l
, GFS2_EA2NAME(ea
),
395 er
->er_data
[ei
->ei_size
+ ea_size
- 1] = 0;
398 ei
->ei_size
+= ea_size
;
404 * gfs2_listxattr - List gfs2 extended attributes
405 * @dentry: The dentry whose inode we are interested in
406 * @buffer: The buffer to write the results
407 * @size: The size of the buffer
409 * Returns: actual size of data on success, -errno on error
412 ssize_t
gfs2_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
414 struct gfs2_inode
*ip
= GFS2_I(d_inode(dentry
));
415 struct gfs2_ea_request er
;
416 struct gfs2_holder i_gh
;
419 memset(&er
, 0, sizeof(struct gfs2_ea_request
));
422 er
.er_data_len
= size
;
425 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &i_gh
);
430 struct ea_list ei
= { .ei_er
= &er
, .ei_size
= 0 };
432 error
= ea_foreach(ip
, ea_list_i
, &ei
);
437 gfs2_glock_dq_uninit(&i_gh
);
443 * gfs2_iter_unstuffed - copies the unstuffed xattr data to/from the
445 * @ip: The GFS2 inode
446 * @ea: The extended attribute header structure
447 * @din: The data to be copied in
448 * @dout: The data to be copied out (one of din,dout will be NULL)
453 static int gfs2_iter_unstuffed(struct gfs2_inode
*ip
, struct gfs2_ea_header
*ea
,
454 const char *din
, char *dout
)
456 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
457 struct buffer_head
**bh
;
458 unsigned int amount
= GFS2_EA_DATA_LEN(ea
);
459 unsigned int nptrs
= DIV_ROUND_UP(amount
, sdp
->sd_jbsize
);
460 __be64
*dataptrs
= GFS2_EA2DATAPTRS(ea
);
466 bh
= kcalloc(nptrs
, sizeof(struct buffer_head
*), GFP_NOFS
);
470 for (x
= 0; x
< nptrs
; x
++) {
471 error
= gfs2_meta_read(ip
->i_gl
, be64_to_cpu(*dataptrs
), 0, 0,
481 for (x
= 0; x
< nptrs
; x
++) {
482 error
= gfs2_meta_wait(sdp
, bh
[x
]);
484 for (; x
< nptrs
; x
++)
488 if (gfs2_metatype_check(sdp
, bh
[x
], GFS2_METATYPE_ED
)) {
489 for (; x
< nptrs
; x
++)
495 pos
= bh
[x
]->b_data
+ sizeof(struct gfs2_meta_header
);
496 cp_size
= (sdp
->sd_jbsize
> amount
) ? amount
: sdp
->sd_jbsize
;
499 memcpy(dout
, pos
, cp_size
);
500 dout
+= sdp
->sd_jbsize
;
504 gfs2_trans_add_meta(ip
->i_gl
, bh
[x
]);
505 memcpy(pos
, din
, cp_size
);
506 din
+= sdp
->sd_jbsize
;
509 amount
-= sdp
->sd_jbsize
;
518 static int gfs2_ea_get_copy(struct gfs2_inode
*ip
, struct gfs2_ea_location
*el
,
519 char *data
, size_t size
)
522 size_t len
= GFS2_EA_DATA_LEN(el
->el_ea
);
526 if (GFS2_EA_IS_STUFFED(el
->el_ea
)) {
527 memcpy(data
, GFS2_EA2DATA(el
->el_ea
), len
);
530 ret
= gfs2_iter_unstuffed(ip
, el
->el_ea
, NULL
, data
);
536 int gfs2_xattr_acl_get(struct gfs2_inode
*ip
, const char *name
, char **ppdata
)
538 struct gfs2_ea_location el
;
543 error
= gfs2_ea_find(ip
, GFS2_EATYPE_SYS
, name
, &el
);
548 if (!GFS2_EA_DATA_LEN(el
.el_ea
))
551 len
= GFS2_EA_DATA_LEN(el
.el_ea
);
552 data
= kmalloc(len
, GFP_NOFS
);
557 error
= gfs2_ea_get_copy(ip
, &el
, data
, len
);
568 * __gfs2_xattr_get - Get a GFS2 extended attribute
570 * @name: The name of the extended attribute
571 * @buffer: The buffer to write the result into
572 * @size: The size of the buffer
573 * @type: The type of extended attribute
575 * Returns: actual size of data on success, -errno on error
577 static int __gfs2_xattr_get(struct inode
*inode
, const char *name
,
578 void *buffer
, size_t size
, int type
)
580 struct gfs2_inode
*ip
= GFS2_I(inode
);
581 struct gfs2_ea_location el
;
586 if (strlen(name
) > GFS2_EA_MAX_NAME_LEN
)
589 error
= gfs2_ea_find(ip
, type
, name
, &el
);
595 error
= gfs2_ea_get_copy(ip
, &el
, buffer
, size
);
597 error
= GFS2_EA_DATA_LEN(el
.el_ea
);
603 static int gfs2_xattr_get(const struct xattr_handler
*handler
,
604 struct dentry
*unused
, struct inode
*inode
,
605 const char *name
, void *buffer
, size_t size
)
607 struct gfs2_inode
*ip
= GFS2_I(inode
);
608 struct gfs2_holder gh
;
611 /* During lookup, SELinux calls this function with the glock locked. */
613 if (!gfs2_glock_is_locked_by_me(ip
->i_gl
)) {
614 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &gh
);
618 gfs2_holder_mark_uninitialized(&gh
);
620 ret
= __gfs2_xattr_get(inode
, name
, buffer
, size
, handler
->flags
);
621 if (gfs2_holder_initialized(&gh
))
622 gfs2_glock_dq_uninit(&gh
);
627 * ea_alloc_blk - allocates a new block for extended attributes.
628 * @ip: A pointer to the inode that's getting extended attributes
629 * @bhp: Pointer to pointer to a struct buffer_head
634 static int ea_alloc_blk(struct gfs2_inode
*ip
, struct buffer_head
**bhp
)
636 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
637 struct gfs2_ea_header
*ea
;
642 error
= gfs2_alloc_blocks(ip
, &block
, &n
, 0, NULL
);
645 gfs2_trans_remove_revoke(sdp
, block
, 1);
646 *bhp
= gfs2_meta_new(ip
->i_gl
, block
);
647 gfs2_trans_add_meta(ip
->i_gl
, *bhp
);
648 gfs2_metatype_set(*bhp
, GFS2_METATYPE_EA
, GFS2_FORMAT_EA
);
649 gfs2_buffer_clear_tail(*bhp
, sizeof(struct gfs2_meta_header
));
651 ea
= GFS2_EA_BH2FIRST(*bhp
);
652 ea
->ea_rec_len
= cpu_to_be32(sdp
->sd_jbsize
);
653 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
654 ea
->ea_flags
= GFS2_EAFLAG_LAST
;
657 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
663 * ea_write - writes the request info to an ea, creating new blocks if
665 * @ip: inode that is being modified
666 * @ea: the location of the new ea in a block
667 * @er: the write request
669 * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
674 static int ea_write(struct gfs2_inode
*ip
, struct gfs2_ea_header
*ea
,
675 struct gfs2_ea_request
*er
)
677 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
680 ea
->ea_data_len
= cpu_to_be32(er
->er_data_len
);
681 ea
->ea_name_len
= er
->er_name_len
;
682 ea
->ea_type
= er
->er_type
;
685 memcpy(GFS2_EA2NAME(ea
), er
->er_name
, er
->er_name_len
);
687 if (GFS2_EAREQ_SIZE_STUFFED(er
) <= sdp
->sd_jbsize
) {
689 memcpy(GFS2_EA2DATA(ea
), er
->er_data
, er
->er_data_len
);
691 __be64
*dataptr
= GFS2_EA2DATAPTRS(ea
);
692 const char *data
= er
->er_data
;
693 unsigned int data_len
= er
->er_data_len
;
697 ea
->ea_num_ptrs
= DIV_ROUND_UP(er
->er_data_len
, sdp
->sd_jbsize
);
698 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++) {
699 struct buffer_head
*bh
;
701 int mh_size
= sizeof(struct gfs2_meta_header
);
704 error
= gfs2_alloc_blocks(ip
, &block
, &n
, 0, NULL
);
707 gfs2_trans_remove_revoke(sdp
, block
, 1);
708 bh
= gfs2_meta_new(ip
->i_gl
, block
);
709 gfs2_trans_add_meta(ip
->i_gl
, bh
);
710 gfs2_metatype_set(bh
, GFS2_METATYPE_ED
, GFS2_FORMAT_ED
);
712 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
714 copy
= data_len
> sdp
->sd_jbsize
? sdp
->sd_jbsize
:
716 memcpy(bh
->b_data
+ mh_size
, data
, copy
);
717 if (copy
< sdp
->sd_jbsize
)
718 memset(bh
->b_data
+ mh_size
+ copy
, 0,
719 sdp
->sd_jbsize
- copy
);
721 *dataptr
++ = cpu_to_be64(bh
->b_blocknr
);
728 gfs2_assert_withdraw(sdp
, !data_len
);
734 typedef int (*ea_skeleton_call_t
) (struct gfs2_inode
*ip
,
735 struct gfs2_ea_request
*er
, void *private);
737 static int ea_alloc_skeleton(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
739 ea_skeleton_call_t skeleton_call
, void *private)
741 struct gfs2_alloc_parms ap
= { .target
= blks
};
744 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
748 error
= gfs2_quota_lock_check(ip
, &ap
);
752 error
= gfs2_inplace_reserve(ip
, &ap
);
756 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
),
757 blks
+ gfs2_rg_blocks(ip
, blks
) +
758 RES_DINODE
+ RES_STATFS
+ RES_QUOTA
, 0);
762 error
= skeleton_call(ip
, er
, private);
766 ip
->i_inode
.i_ctime
= current_time(&ip
->i_inode
);
767 __mark_inode_dirty(&ip
->i_inode
, I_DIRTY_DATASYNC
);
770 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
772 gfs2_inplace_release(ip
);
774 gfs2_quota_unlock(ip
);
778 static int ea_init_i(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
781 struct buffer_head
*bh
;
784 error
= ea_alloc_blk(ip
, &bh
);
788 ip
->i_eattr
= bh
->b_blocknr
;
789 error
= ea_write(ip
, GFS2_EA_BH2FIRST(bh
), er
);
797 * ea_init - initializes a new eattr block
801 static int ea_init(struct gfs2_inode
*ip
, int type
, const char *name
,
802 const void *data
, size_t size
)
804 struct gfs2_ea_request er
;
805 unsigned int jbsize
= GFS2_SB(&ip
->i_inode
)->sd_jbsize
;
806 unsigned int blks
= 1;
810 er
.er_name_len
= strlen(name
);
811 er
.er_data
= (void *)data
;
812 er
.er_data_len
= size
;
814 if (GFS2_EAREQ_SIZE_STUFFED(&er
) > jbsize
)
815 blks
+= DIV_ROUND_UP(er
.er_data_len
, jbsize
);
817 return ea_alloc_skeleton(ip
, &er
, blks
, ea_init_i
, NULL
);
820 static struct gfs2_ea_header
*ea_split_ea(struct gfs2_ea_header
*ea
)
822 u32 ea_size
= GFS2_EA_SIZE(ea
);
823 struct gfs2_ea_header
*new = (struct gfs2_ea_header
*)((char *)ea
+
825 u32 new_size
= GFS2_EA_REC_LEN(ea
) - ea_size
;
826 int last
= ea
->ea_flags
& GFS2_EAFLAG_LAST
;
828 ea
->ea_rec_len
= cpu_to_be32(ea_size
);
829 ea
->ea_flags
^= last
;
831 new->ea_rec_len
= cpu_to_be32(new_size
);
832 new->ea_flags
= last
;
837 static void ea_set_remove_stuffed(struct gfs2_inode
*ip
,
838 struct gfs2_ea_location
*el
)
840 struct gfs2_ea_header
*ea
= el
->el_ea
;
841 struct gfs2_ea_header
*prev
= el
->el_prev
;
844 gfs2_trans_add_meta(ip
->i_gl
, el
->el_bh
);
846 if (!prev
|| !GFS2_EA_IS_STUFFED(ea
)) {
847 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
849 } else if (GFS2_EA2NEXT(prev
) != ea
) {
850 prev
= GFS2_EA2NEXT(prev
);
851 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
), GFS2_EA2NEXT(prev
) == ea
);
854 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
855 prev
->ea_rec_len
= cpu_to_be32(len
);
857 if (GFS2_EA_IS_LAST(ea
))
858 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
864 struct gfs2_ea_request
*es_er
;
865 struct gfs2_ea_location
*es_el
;
867 struct buffer_head
*es_bh
;
868 struct gfs2_ea_header
*es_ea
;
871 static int ea_set_simple_noalloc(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
872 struct gfs2_ea_header
*ea
, struct ea_set
*es
)
874 struct gfs2_ea_request
*er
= es
->es_er
;
877 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ 2 * RES_EATTR
, 0);
881 gfs2_trans_add_meta(ip
->i_gl
, bh
);
884 ea
= ea_split_ea(ea
);
886 ea_write(ip
, ea
, er
);
889 ea_set_remove_stuffed(ip
, es
->es_el
);
891 ip
->i_inode
.i_ctime
= current_time(&ip
->i_inode
);
892 __mark_inode_dirty(&ip
->i_inode
, I_DIRTY_DATASYNC
);
894 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
898 static int ea_set_simple_alloc(struct gfs2_inode
*ip
,
899 struct gfs2_ea_request
*er
, void *private)
901 struct ea_set
*es
= private;
902 struct gfs2_ea_header
*ea
= es
->es_ea
;
905 gfs2_trans_add_meta(ip
->i_gl
, es
->es_bh
);
908 ea
= ea_split_ea(ea
);
910 error
= ea_write(ip
, ea
, er
);
915 ea_set_remove_stuffed(ip
, es
->es_el
);
920 static int ea_set_simple(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
921 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
924 struct ea_set
*es
= private;
929 stuffed
= ea_calc_size(GFS2_SB(&ip
->i_inode
), es
->es_er
->er_name_len
,
930 es
->es_er
->er_data_len
, &size
);
932 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
) {
933 if (GFS2_EA_REC_LEN(ea
) < size
)
935 if (!GFS2_EA_IS_STUFFED(ea
)) {
936 error
= ea_remove_unstuffed(ip
, bh
, ea
, prev
, 1);
941 } else if (GFS2_EA_REC_LEN(ea
) - GFS2_EA_SIZE(ea
) >= size
)
947 error
= ea_set_simple_noalloc(ip
, bh
, ea
, es
);
955 blks
= 2 + DIV_ROUND_UP(es
->es_er
->er_data_len
,
956 GFS2_SB(&ip
->i_inode
)->sd_jbsize
);
958 error
= ea_alloc_skeleton(ip
, es
->es_er
, blks
,
959 ea_set_simple_alloc
, es
);
967 static int ea_set_block(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
970 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
971 struct buffer_head
*indbh
, *newbh
;
974 int mh_size
= sizeof(struct gfs2_meta_header
);
976 if (ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
) {
979 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, 0,
984 if (gfs2_metatype_check(sdp
, indbh
, GFS2_METATYPE_IN
)) {
989 eablk
= (__be64
*)(indbh
->b_data
+ mh_size
);
990 end
= eablk
+ sdp
->sd_inptrs
;
992 for (; eablk
< end
; eablk
++)
1001 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1005 error
= gfs2_alloc_blocks(ip
, &blk
, &n
, 0, NULL
);
1008 gfs2_trans_remove_revoke(sdp
, blk
, 1);
1009 indbh
= gfs2_meta_new(ip
->i_gl
, blk
);
1010 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1011 gfs2_metatype_set(indbh
, GFS2_METATYPE_IN
, GFS2_FORMAT_IN
);
1012 gfs2_buffer_clear_tail(indbh
, mh_size
);
1014 eablk
= (__be64
*)(indbh
->b_data
+ mh_size
);
1015 *eablk
= cpu_to_be64(ip
->i_eattr
);
1017 ip
->i_diskflags
|= GFS2_DIF_EA_INDIRECT
;
1018 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
1023 error
= ea_alloc_blk(ip
, &newbh
);
1027 *eablk
= cpu_to_be64((u64
)newbh
->b_blocknr
);
1028 error
= ea_write(ip
, GFS2_EA_BH2FIRST(newbh
), er
);
1034 ea_set_remove_stuffed(ip
, private);
1041 static int ea_set_i(struct gfs2_inode
*ip
, int type
, const char *name
,
1042 const void *value
, size_t size
, struct gfs2_ea_location
*el
)
1044 struct gfs2_ea_request er
;
1046 unsigned int blks
= 2;
1051 er
.er_data
= (void *)value
;
1052 er
.er_name_len
= strlen(name
);
1053 er
.er_data_len
= size
;
1055 memset(&es
, 0, sizeof(struct ea_set
));
1059 error
= ea_foreach(ip
, ea_set_simple
, &es
);
1065 if (!(ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
))
1067 if (GFS2_EAREQ_SIZE_STUFFED(&er
) > GFS2_SB(&ip
->i_inode
)->sd_jbsize
)
1068 blks
+= DIV_ROUND_UP(er
.er_data_len
, GFS2_SB(&ip
->i_inode
)->sd_jbsize
);
1070 return ea_alloc_skeleton(ip
, &er
, blks
, ea_set_block
, el
);
1073 static int ea_set_remove_unstuffed(struct gfs2_inode
*ip
,
1074 struct gfs2_ea_location
*el
)
1076 if (el
->el_prev
&& GFS2_EA2NEXT(el
->el_prev
) != el
->el_ea
) {
1077 el
->el_prev
= GFS2_EA2NEXT(el
->el_prev
);
1078 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
),
1079 GFS2_EA2NEXT(el
->el_prev
) == el
->el_ea
);
1082 return ea_remove_unstuffed(ip
, el
->el_bh
, el
->el_ea
, el
->el_prev
, 0);
1085 static int ea_remove_stuffed(struct gfs2_inode
*ip
, struct gfs2_ea_location
*el
)
1087 struct gfs2_ea_header
*ea
= el
->el_ea
;
1088 struct gfs2_ea_header
*prev
= el
->el_prev
;
1091 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ RES_EATTR
, 0);
1095 gfs2_trans_add_meta(ip
->i_gl
, el
->el_bh
);
1100 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
1101 prev
->ea_rec_len
= cpu_to_be32(len
);
1103 if (GFS2_EA_IS_LAST(ea
))
1104 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
1106 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
1109 ip
->i_inode
.i_ctime
= current_time(&ip
->i_inode
);
1110 __mark_inode_dirty(&ip
->i_inode
, I_DIRTY_DATASYNC
);
1112 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
1118 * gfs2_xattr_remove - Remove a GFS2 extended attribute
1120 * @type: The type of the extended attribute
1121 * @name: The name of the extended attribute
1123 * This is not called directly by the VFS since we use the (common)
1124 * scheme of making a "set with NULL data" mean a remove request. Note
1125 * that this is different from a set with zero length data.
1127 * Returns: 0, or errno on failure
1130 static int gfs2_xattr_remove(struct gfs2_inode
*ip
, int type
, const char *name
)
1132 struct gfs2_ea_location el
;
1138 error
= gfs2_ea_find(ip
, type
, name
, &el
);
1144 if (GFS2_EA_IS_STUFFED(el
.el_ea
))
1145 error
= ea_remove_stuffed(ip
, &el
);
1147 error
= ea_remove_unstuffed(ip
, el
.el_bh
, el
.el_ea
, el
.el_prev
, 0);
1155 * __gfs2_xattr_set - Set (or remove) a GFS2 extended attribute
1157 * @name: The name of the extended attribute
1158 * @value: The value of the extended attribute (NULL for remove)
1159 * @size: The size of the @value argument
1160 * @flags: Create or Replace
1161 * @type: The type of the extended attribute
1163 * See gfs2_xattr_remove() for details of the removal of xattrs.
1165 * Returns: 0 or errno on failure
1168 int __gfs2_xattr_set(struct inode
*inode
, const char *name
,
1169 const void *value
, size_t size
, int flags
, int type
)
1171 struct gfs2_inode
*ip
= GFS2_I(inode
);
1172 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1173 struct gfs2_ea_location el
;
1174 unsigned int namel
= strlen(name
);
1177 if (IS_IMMUTABLE(inode
) || IS_APPEND(inode
))
1179 if (namel
> GFS2_EA_MAX_NAME_LEN
)
1182 if (value
== NULL
) {
1183 error
= gfs2_xattr_remove(ip
, type
, name
);
1184 if (error
== -ENODATA
&& !(flags
& XATTR_REPLACE
))
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 gfs2_xattr_set(const struct xattr_handler
*handler
,
1228 struct user_namespace
*mnt_userns
,
1229 struct dentry
*unused
, struct inode
*inode
,
1230 const char *name
, const void *value
,
1231 size_t size
, int flags
)
1233 struct gfs2_inode
*ip
= GFS2_I(inode
);
1234 struct gfs2_holder gh
;
1237 ret
= gfs2_qa_get(ip
);
1241 /* May be called from gfs_setattr with the glock locked. */
1243 if (!gfs2_glock_is_locked_by_me(ip
->i_gl
)) {
1244 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
1248 if (WARN_ON_ONCE(ip
->i_gl
->gl_state
!= LM_ST_EXCLUSIVE
)) {
1252 gfs2_holder_mark_uninitialized(&gh
);
1254 ret
= __gfs2_xattr_set(inode
, name
, value
, size
, flags
, handler
->flags
);
1255 if (gfs2_holder_initialized(&gh
))
1256 gfs2_glock_dq_uninit(&gh
);
1262 static int ea_dealloc_indirect(struct gfs2_inode
*ip
)
1264 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1265 struct gfs2_rgrp_list rlist
;
1266 struct gfs2_rgrpd
*rgd
;
1267 struct buffer_head
*indbh
, *dibh
;
1268 __be64
*eablk
, *end
;
1269 unsigned int rg_blocks
= 0;
1271 unsigned int blen
= 0;
1272 unsigned int blks
= 0;
1276 error
= gfs2_rindex_update(sdp
);
1280 memset(&rlist
, 0, sizeof(struct gfs2_rgrp_list
));
1282 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, 0, &indbh
);
1286 if (gfs2_metatype_check(sdp
, indbh
, GFS2_METATYPE_IN
)) {
1291 eablk
= (__be64
*)(indbh
->b_data
+ sizeof(struct gfs2_meta_header
));
1292 end
= eablk
+ sdp
->sd_inptrs
;
1294 for (; eablk
< end
; eablk
++) {
1299 bn
= be64_to_cpu(*eablk
);
1301 if (bstart
+ blen
== bn
)
1305 gfs2_rlist_add(ip
, &rlist
, bstart
);
1312 gfs2_rlist_add(ip
, &rlist
, bstart
);
1316 gfs2_rlist_alloc(&rlist
);
1318 for (x
= 0; x
< rlist
.rl_rgrps
; x
++) {
1319 rgd
= gfs2_glock2rgrp(rlist
.rl_ghs
[x
].gh_gl
);
1320 rg_blocks
+= rgd
->rd_length
;
1323 error
= gfs2_glock_nq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
1325 goto out_rlist_free
;
1327 error
= gfs2_trans_begin(sdp
, rg_blocks
+ RES_DINODE
+ RES_INDIRECT
+
1328 RES_STATFS
+ RES_QUOTA
, blks
);
1332 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1334 eablk
= (__be64
*)(indbh
->b_data
+ sizeof(struct gfs2_meta_header
));
1339 for (; eablk
< end
; eablk
++) {
1344 bn
= be64_to_cpu(*eablk
);
1346 if (bstart
+ blen
== bn
)
1350 gfs2_free_meta(ip
, rgd
, bstart
, blen
);
1352 rgd
= gfs2_blk2rgrpd(sdp
, bstart
, true);
1357 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
1360 gfs2_free_meta(ip
, rgd
, bstart
, blen
);
1362 ip
->i_diskflags
&= ~GFS2_DIF_EA_INDIRECT
;
1364 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1366 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
1367 gfs2_dinode_out(ip
, dibh
->b_data
);
1371 gfs2_trans_end(sdp
);
1374 gfs2_glock_dq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
1376 gfs2_rlist_free(&rlist
);
1382 static int ea_dealloc_block(struct gfs2_inode
*ip
)
1384 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1385 struct gfs2_rgrpd
*rgd
;
1386 struct buffer_head
*dibh
;
1387 struct gfs2_holder gh
;
1390 error
= gfs2_rindex_update(sdp
);
1394 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_eattr
, 1);
1396 gfs2_consist_inode(ip
);
1400 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
,
1401 LM_FLAG_NODE_SCOPE
, &gh
);
1405 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_DINODE
+ RES_STATFS
+
1410 gfs2_free_meta(ip
, rgd
, ip
->i_eattr
, 1);
1413 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
1415 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1417 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
1418 gfs2_dinode_out(ip
, dibh
->b_data
);
1422 gfs2_trans_end(sdp
);
1425 gfs2_glock_dq_uninit(&gh
);
1430 * gfs2_ea_dealloc - deallocate the extended attribute fork
1436 int gfs2_ea_dealloc(struct gfs2_inode
*ip
)
1440 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
1444 error
= gfs2_quota_hold(ip
, NO_UID_QUOTA_CHANGE
, NO_GID_QUOTA_CHANGE
);
1448 error
= ea_foreach(ip
, ea_dealloc_unstuffed
, NULL
);
1452 if (ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
) {
1453 error
= ea_dealloc_indirect(ip
);
1458 error
= ea_dealloc_block(ip
);
1461 gfs2_quota_unhold(ip
);
1465 static const struct xattr_handler gfs2_xattr_user_handler
= {
1466 .prefix
= XATTR_USER_PREFIX
,
1467 .flags
= GFS2_EATYPE_USR
,
1468 .get
= gfs2_xattr_get
,
1469 .set
= gfs2_xattr_set
,
1472 static const struct xattr_handler gfs2_xattr_security_handler
= {
1473 .prefix
= XATTR_SECURITY_PREFIX
,
1474 .flags
= GFS2_EATYPE_SECURITY
,
1475 .get
= gfs2_xattr_get
,
1476 .set
= gfs2_xattr_set
,
1480 gfs2_xattr_trusted_list(struct dentry
*dentry
)
1482 return capable(CAP_SYS_ADMIN
);
1485 static const struct xattr_handler gfs2_xattr_trusted_handler
= {
1486 .prefix
= XATTR_TRUSTED_PREFIX
,
1487 .flags
= GFS2_EATYPE_TRUSTED
,
1488 .list
= gfs2_xattr_trusted_list
,
1489 .get
= gfs2_xattr_get
,
1490 .set
= gfs2_xattr_set
,
1493 const struct xattr_handler
*gfs2_xattr_handlers_max
[] = {
1494 /* GFS2_FS_FORMAT_MAX */
1495 &gfs2_xattr_trusted_handler
,
1497 /* GFS2_FS_FORMAT_MIN */
1498 &gfs2_xattr_user_handler
,
1499 &gfs2_xattr_security_handler
,
1500 &posix_acl_access_xattr_handler
,
1501 &posix_acl_default_xattr_handler
,
1505 const struct xattr_handler
**gfs2_xattr_handlers_min
= gfs2_xattr_handlers_max
+ 1;