~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_attr_inactive.c

Version: ~ [ linux-6.11-rc3 ] ~ [ linux-6.10.4 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.45 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.104 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.164 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.223 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.281 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.319 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  4  * Copyright (c) 2013 Red Hat, Inc.
  5  * All Rights Reserved.
  6  */
  7 #include "xfs.h"
  8 #include "xfs_fs.h"
  9 #include "xfs_shared.h"
 10 #include "xfs_format.h"
 11 #include "xfs_log_format.h"
 12 #include "xfs_trans_resv.h"
 13 #include "xfs_bit.h"
 14 #include "xfs_mount.h"
 15 #include "xfs_da_format.h"
 16 #include "xfs_da_btree.h"
 17 #include "xfs_inode.h"
 18 #include "xfs_attr.h"
 19 #include "xfs_attr_remote.h"
 20 #include "xfs_trans.h"
 21 #include "xfs_bmap.h"
 22 #include "xfs_attr_leaf.h"
 23 #include "xfs_quota.h"
 24 #include "xfs_dir2.h"
 25 #include "xfs_error.h"
 26 #include "xfs_health.h"
 27 
 28 /*
 29  * Invalidate any incore buffers associated with this remote attribute value
 30  * extent.   We never log remote attribute value buffers, which means that they
 31  * won't be attached to a transaction and are therefore safe to mark stale.
 32  * The actual bunmapi will be taken care of later.
 33  */
 34 STATIC int
 35 xfs_attr3_rmt_stale(
 36         struct xfs_inode        *dp,
 37         xfs_dablk_t             blkno,
 38         int                     blkcnt)
 39 {
 40         struct xfs_bmbt_irec    map;
 41         int                     nmap;
 42         int                     error;
 43 
 44         /*
 45          * Roll through the "value", invalidating the attribute value's
 46          * blocks.
 47          */
 48         while (blkcnt > 0) {
 49                 /*
 50                  * Try to remember where we decided to put the value.
 51                  */
 52                 nmap = 1;
 53                 error = xfs_bmapi_read(dp, (xfs_fileoff_t)blkno, blkcnt,
 54                                        &map, &nmap, XFS_BMAPI_ATTRFORK);
 55                 if (error)
 56                         return error;
 57                 if (XFS_IS_CORRUPT(dp->i_mount, nmap != 1))
 58                         return -EFSCORRUPTED;
 59 
 60                 /*
 61                  * Mark any incore buffers for the remote value as stale.  We
 62                  * never log remote attr value buffers, so the buffer should be
 63                  * easy to kill.
 64                  */
 65                 error = xfs_attr_rmtval_stale(dp, &map, 0);
 66                 if (error)
 67                         return error;
 68 
 69                 blkno += map.br_blockcount;
 70                 blkcnt -= map.br_blockcount;
 71         }
 72 
 73         return 0;
 74 }
 75 
 76 /*
 77  * Invalidate all of the "remote" value regions pointed to by a particular
 78  * leaf block.
 79  * Note that we must release the lock on the buffer so that we are not
 80  * caught holding something that the logging code wants to flush to disk.
 81  */
 82 STATIC int
 83 xfs_attr3_leaf_inactive(
 84         struct xfs_trans                **trans,
 85         struct xfs_inode                *dp,
 86         struct xfs_buf                  *bp)
 87 {
 88         struct xfs_attr3_icleaf_hdr     ichdr;
 89         struct xfs_mount                *mp = bp->b_mount;
 90         struct xfs_attr_leafblock       *leaf = bp->b_addr;
 91         struct xfs_attr_leaf_entry      *entry;
 92         struct xfs_attr_leaf_name_remote *name_rmt;
 93         int                             error = 0;
 94         int                             i;
 95 
 96         xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);
 97 
 98         /*
 99          * Find the remote value extents for this leaf and invalidate their
100          * incore buffers.
101          */
102         entry = xfs_attr3_leaf_entryp(leaf);
103         for (i = 0; i < ichdr.count; entry++, i++) {
104                 int             blkcnt;
105 
106                 if (!entry->nameidx || (entry->flags & XFS_ATTR_LOCAL))
107                         continue;
108 
109                 name_rmt = xfs_attr3_leaf_name_remote(leaf, i);
110                 if (!name_rmt->valueblk)
111                         continue;
112 
113                 blkcnt = xfs_attr3_rmt_blocks(dp->i_mount,
114                                 be32_to_cpu(name_rmt->valuelen));
115                 error = xfs_attr3_rmt_stale(dp,
116                                 be32_to_cpu(name_rmt->valueblk), blkcnt);
117                 if (error)
118                         goto err;
119         }
120 
121         xfs_trans_brelse(*trans, bp);
122 err:
123         return error;
124 }
125 
126 /*
127  * Recurse (gasp!) through the attribute nodes until we find leaves.
128  * We're doing a depth-first traversal in order to invalidate everything.
129  */
130 STATIC int
131 xfs_attr3_node_inactive(
132         struct xfs_trans        **trans,
133         struct xfs_inode        *dp,
134         struct xfs_buf          *bp,
135         int                     level)
136 {
137         struct xfs_mount        *mp = dp->i_mount;
138         struct xfs_da_blkinfo   *info;
139         xfs_dablk_t             child_fsb;
140         xfs_daddr_t             parent_blkno, child_blkno;
141         struct xfs_buf          *child_bp;
142         struct xfs_da3_icnode_hdr ichdr;
143         int                     error, i;
144 
145         /*
146          * Since this code is recursive (gasp!) we must protect ourselves.
147          */
148         if (level > XFS_DA_NODE_MAXDEPTH) {
149                 xfs_buf_mark_corrupt(bp);
150                 xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
151                 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK);
152                 return -EFSCORRUPTED;
153         }
154 
155         xfs_da3_node_hdr_from_disk(dp->i_mount, &ichdr, bp->b_addr);
156         parent_blkno = xfs_buf_daddr(bp);
157         if (!ichdr.count) {
158                 xfs_trans_brelse(*trans, bp);
159                 return 0;
160         }
161         child_fsb = be32_to_cpu(ichdr.btree[0].before);
162         xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
163         bp = NULL;
164 
165         /*
166          * If this is the node level just above the leaves, simply loop
167          * over the leaves removing all of them.  If this is higher up
168          * in the tree, recurse downward.
169          */
170         for (i = 0; i < ichdr.count; i++) {
171                 /*
172                  * Read the subsidiary block to see what we have to work with.
173                  * Don't do this in a transaction.  This is a depth-first
174                  * traversal of the tree so we may deal with many blocks
175                  * before we come back to this one.
176                  */
177                 error = xfs_da3_node_read(*trans, dp, child_fsb, &child_bp,
178                                           XFS_ATTR_FORK);
179                 if (error)
180                         return error;
181 
182                 /* save for re-read later */
183                 child_blkno = xfs_buf_daddr(child_bp);
184 
185                 /*
186                  * Invalidate the subtree, however we have to.
187                  */
188                 info = child_bp->b_addr;
189                 switch (info->magic) {
190                 case cpu_to_be16(XFS_DA_NODE_MAGIC):
191                 case cpu_to_be16(XFS_DA3_NODE_MAGIC):
192                         error = xfs_attr3_node_inactive(trans, dp, child_bp,
193                                                         level + 1);
194                         break;
195                 case cpu_to_be16(XFS_ATTR_LEAF_MAGIC):
196                 case cpu_to_be16(XFS_ATTR3_LEAF_MAGIC):
197                         error = xfs_attr3_leaf_inactive(trans, dp, child_bp);
198                         break;
199                 default:
200                         xfs_buf_mark_corrupt(child_bp);
201                         xfs_trans_brelse(*trans, child_bp);
202                         xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK);
203                         error = -EFSCORRUPTED;
204                         break;
205                 }
206                 if (error)
207                         return error;
208 
209                 /*
210                  * Remove the subsidiary block from the cache and from the log.
211                  */
212                 error = xfs_trans_get_buf(*trans, mp->m_ddev_targp,
213                                 child_blkno,
214                                 XFS_FSB_TO_BB(mp, mp->m_attr_geo->fsbcount), 0,
215                                 &child_bp);
216                 if (error)
217                         return error;
218                 xfs_trans_binval(*trans, child_bp);
219                 child_bp = NULL;
220 
221                 /*
222                  * If we're not done, re-read the parent to get the next
223                  * child block number.
224                  */
225                 if (i + 1 < ichdr.count) {
226                         struct xfs_da3_icnode_hdr phdr;
227 
228                         error = xfs_da3_node_read_mapped(*trans, dp,
229                                         parent_blkno, &bp, XFS_ATTR_FORK);
230                         if (error)
231                                 return error;
232                         xfs_da3_node_hdr_from_disk(dp->i_mount, &phdr,
233                                                   bp->b_addr);
234                         child_fsb = be32_to_cpu(phdr.btree[i + 1].before);
235                         xfs_trans_brelse(*trans, bp);
236                         bp = NULL;
237                 }
238                 /*
239                  * Atomically commit the whole invalidate stuff.
240                  */
241                 error = xfs_trans_roll_inode(trans, dp);
242                 if (error)
243                         return  error;
244         }
245 
246         return 0;
247 }
248 
249 /*
250  * Indiscriminately delete the entire attribute fork
251  *
252  * Recurse (gasp!) through the attribute nodes until we find leaves.
253  * We're doing a depth-first traversal in order to invalidate everything.
254  */
255 static int
256 xfs_attr3_root_inactive(
257         struct xfs_trans        **trans,
258         struct xfs_inode        *dp)
259 {
260         struct xfs_mount        *mp = dp->i_mount;
261         struct xfs_da_blkinfo   *info;
262         struct xfs_buf          *bp;
263         xfs_daddr_t             blkno;
264         int                     error;
265 
266         /*
267          * Read block 0 to see what we have to work with.
268          * We only get here if we have extents, since we remove
269          * the extents in reverse order the extent containing
270          * block 0 must still be there.
271          */
272         error = xfs_da3_node_read(*trans, dp, 0, &bp, XFS_ATTR_FORK);
273         if (error)
274                 return error;
275         blkno = xfs_buf_daddr(bp);
276 
277         /*
278          * Invalidate the tree, even if the "tree" is only a single leaf block.
279          * This is a depth-first traversal!
280          */
281         info = bp->b_addr;
282         switch (info->magic) {
283         case cpu_to_be16(XFS_DA_NODE_MAGIC):
284         case cpu_to_be16(XFS_DA3_NODE_MAGIC):
285                 error = xfs_attr3_node_inactive(trans, dp, bp, 1);
286                 break;
287         case cpu_to_be16(XFS_ATTR_LEAF_MAGIC):
288         case cpu_to_be16(XFS_ATTR3_LEAF_MAGIC):
289                 error = xfs_attr3_leaf_inactive(trans, dp, bp);
290                 break;
291         default:
292                 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK);
293                 error = -EFSCORRUPTED;
294                 xfs_buf_mark_corrupt(bp);
295                 xfs_trans_brelse(*trans, bp);
296                 break;
297         }
298         if (error)
299                 return error;
300 
301         /*
302          * Invalidate the incore copy of the root block.
303          */
304         error = xfs_trans_get_buf(*trans, mp->m_ddev_targp, blkno,
305                         XFS_FSB_TO_BB(mp, mp->m_attr_geo->fsbcount), 0, &bp);
306         if (error)
307                 return error;
308         error = bp->b_error;
309         if (error) {
310                 xfs_trans_brelse(*trans, bp);
311                 return error;
312         }
313         xfs_trans_binval(*trans, bp);   /* remove from cache */
314         /*
315          * Commit the invalidate and start the next transaction.
316          */
317         error = xfs_trans_roll_inode(trans, dp);
318 
319         return error;
320 }
321 
322 /*
323  * xfs_attr_inactive kills all traces of an attribute fork on an inode. It
324  * removes both the on-disk and in-memory inode fork. Note that this also has to
325  * handle the condition of inodes without attributes but with an attribute fork
326  * configured, so we can't use xfs_inode_hasattr() here.
327  *
328  * The in-memory attribute fork is removed even on error.
329  */
330 int
331 xfs_attr_inactive(
332         struct xfs_inode        *dp)
333 {
334         struct xfs_trans        *trans;
335         struct xfs_mount        *mp;
336         int                     lock_mode = XFS_ILOCK_SHARED;
337         int                     error = 0;
338 
339         mp = dp->i_mount;
340 
341         xfs_ilock(dp, lock_mode);
342         if (!xfs_inode_has_attr_fork(dp))
343                 goto out_destroy_fork;
344         xfs_iunlock(dp, lock_mode);
345 
346         lock_mode = 0;
347 
348         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_attrinval, 0, 0, 0, &trans);
349         if (error)
350                 goto out_destroy_fork;
351 
352         lock_mode = XFS_ILOCK_EXCL;
353         xfs_ilock(dp, lock_mode);
354 
355         if (!xfs_inode_has_attr_fork(dp))
356                 goto out_cancel;
357 
358         /*
359          * No need to make quota reservations here. We expect to release some
360          * blocks, not allocate, in the common case.
361          */
362         xfs_trans_ijoin(trans, dp, 0);
363 
364         /*
365          * Invalidate and truncate the attribute fork extents. Make sure the
366          * fork actually has xattr blocks as otherwise the invalidation has no
367          * blocks to read and returns an error. In this case, just do the fork
368          * removal below.
369          */
370         if (dp->i_af.if_nextents > 0) {
371                 error = xfs_attr3_root_inactive(&trans, dp);
372                 if (error)
373                         goto out_cancel;
374 
375                 error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0);
376                 if (error)
377                         goto out_cancel;
378         }
379 
380         /* Reset the attribute fork - this also destroys the in-core fork */
381         xfs_attr_fork_remove(dp, trans);
382 
383         error = xfs_trans_commit(trans);
384         xfs_iunlock(dp, lock_mode);
385         return error;
386 
387 out_cancel:
388         xfs_trans_cancel(trans);
389 out_destroy_fork:
390         /* kill the in-core attr fork before we drop the inode lock */
391         xfs_ifork_zap_attr(dp);
392         if (lock_mode)
393                 xfs_iunlock(dp, lock_mode);
394         return error;
395 }
396 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php