xref: /openbmc/linux/fs/xfs/xfs_attr_inactive.c (revision c819e2cf)
1 /*
2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3  * Copyright (c) 2013 Red Hat, Inc.
4  * All Rights Reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it would be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write the Free Software Foundation,
17  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18  */
19 #include "xfs.h"
20 #include "xfs_fs.h"
21 #include "xfs_shared.h"
22 #include "xfs_format.h"
23 #include "xfs_log_format.h"
24 #include "xfs_trans_resv.h"
25 #include "xfs_bit.h"
26 #include "xfs_mount.h"
27 #include "xfs_da_format.h"
28 #include "xfs_da_btree.h"
29 #include "xfs_inode.h"
30 #include "xfs_alloc.h"
31 #include "xfs_attr_remote.h"
32 #include "xfs_trans.h"
33 #include "xfs_inode_item.h"
34 #include "xfs_bmap.h"
35 #include "xfs_attr.h"
36 #include "xfs_attr_leaf.h"
37 #include "xfs_error.h"
38 #include "xfs_quota.h"
39 #include "xfs_trace.h"
40 #include "xfs_dir2.h"
41 
42 /*
43  * Look at all the extents for this logical region,
44  * invalidate any buffers that are incore/in transactions.
45  */
46 STATIC int
47 xfs_attr3_leaf_freextent(
48 	struct xfs_trans	**trans,
49 	struct xfs_inode	*dp,
50 	xfs_dablk_t		blkno,
51 	int			blkcnt)
52 {
53 	struct xfs_bmbt_irec	map;
54 	struct xfs_buf		*bp;
55 	xfs_dablk_t		tblkno;
56 	xfs_daddr_t		dblkno;
57 	int			tblkcnt;
58 	int			dblkcnt;
59 	int			nmap;
60 	int			error;
61 
62 	/*
63 	 * Roll through the "value", invalidating the attribute value's
64 	 * blocks.
65 	 */
66 	tblkno = blkno;
67 	tblkcnt = blkcnt;
68 	while (tblkcnt > 0) {
69 		/*
70 		 * Try to remember where we decided to put the value.
71 		 */
72 		nmap = 1;
73 		error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
74 				       &map, &nmap, XFS_BMAPI_ATTRFORK);
75 		if (error) {
76 			return error;
77 		}
78 		ASSERT(nmap == 1);
79 		ASSERT(map.br_startblock != DELAYSTARTBLOCK);
80 
81 		/*
82 		 * If it's a hole, these are already unmapped
83 		 * so there's nothing to invalidate.
84 		 */
85 		if (map.br_startblock != HOLESTARTBLOCK) {
86 
87 			dblkno = XFS_FSB_TO_DADDR(dp->i_mount,
88 						  map.br_startblock);
89 			dblkcnt = XFS_FSB_TO_BB(dp->i_mount,
90 						map.br_blockcount);
91 			bp = xfs_trans_get_buf(*trans,
92 					dp->i_mount->m_ddev_targp,
93 					dblkno, dblkcnt, 0);
94 			if (!bp)
95 				return -ENOMEM;
96 			xfs_trans_binval(*trans, bp);
97 			/*
98 			 * Roll to next transaction.
99 			 */
100 			error = xfs_trans_roll(trans, dp);
101 			if (error)
102 				return error;
103 		}
104 
105 		tblkno += map.br_blockcount;
106 		tblkcnt -= map.br_blockcount;
107 	}
108 
109 	return 0;
110 }
111 
112 /*
113  * Invalidate all of the "remote" value regions pointed to by a particular
114  * leaf block.
115  * Note that we must release the lock on the buffer so that we are not
116  * caught holding something that the logging code wants to flush to disk.
117  */
118 STATIC int
119 xfs_attr3_leaf_inactive(
120 	struct xfs_trans	**trans,
121 	struct xfs_inode	*dp,
122 	struct xfs_buf		*bp)
123 {
124 	struct xfs_attr_leafblock *leaf;
125 	struct xfs_attr3_icleaf_hdr ichdr;
126 	struct xfs_attr_leaf_entry *entry;
127 	struct xfs_attr_leaf_name_remote *name_rmt;
128 	struct xfs_attr_inactive_list *list;
129 	struct xfs_attr_inactive_list *lp;
130 	int			error;
131 	int			count;
132 	int			size;
133 	int			tmp;
134 	int			i;
135 
136 	leaf = bp->b_addr;
137 	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);
138 
139 	/*
140 	 * Count the number of "remote" value extents.
141 	 */
142 	count = 0;
143 	entry = xfs_attr3_leaf_entryp(leaf);
144 	for (i = 0; i < ichdr.count; entry++, i++) {
145 		if (be16_to_cpu(entry->nameidx) &&
146 		    ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
147 			name_rmt = xfs_attr3_leaf_name_remote(leaf, i);
148 			if (name_rmt->valueblk)
149 				count++;
150 		}
151 	}
152 
153 	/*
154 	 * If there are no "remote" values, we're done.
155 	 */
156 	if (count == 0) {
157 		xfs_trans_brelse(*trans, bp);
158 		return 0;
159 	}
160 
161 	/*
162 	 * Allocate storage for a list of all the "remote" value extents.
163 	 */
164 	size = count * sizeof(xfs_attr_inactive_list_t);
165 	list = kmem_alloc(size, KM_SLEEP);
166 
167 	/*
168 	 * Identify each of the "remote" value extents.
169 	 */
170 	lp = list;
171 	entry = xfs_attr3_leaf_entryp(leaf);
172 	for (i = 0; i < ichdr.count; entry++, i++) {
173 		if (be16_to_cpu(entry->nameidx) &&
174 		    ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
175 			name_rmt = xfs_attr3_leaf_name_remote(leaf, i);
176 			if (name_rmt->valueblk) {
177 				lp->valueblk = be32_to_cpu(name_rmt->valueblk);
178 				lp->valuelen = xfs_attr3_rmt_blocks(dp->i_mount,
179 						    be32_to_cpu(name_rmt->valuelen));
180 				lp++;
181 			}
182 		}
183 	}
184 	xfs_trans_brelse(*trans, bp);	/* unlock for trans. in freextent() */
185 
186 	/*
187 	 * Invalidate each of the "remote" value extents.
188 	 */
189 	error = 0;
190 	for (lp = list, i = 0; i < count; i++, lp++) {
191 		tmp = xfs_attr3_leaf_freextent(trans, dp,
192 				lp->valueblk, lp->valuelen);
193 
194 		if (error == 0)
195 			error = tmp;	/* save only the 1st errno */
196 	}
197 
198 	kmem_free(list);
199 	return error;
200 }
201 
202 /*
203  * Recurse (gasp!) through the attribute nodes until we find leaves.
204  * We're doing a depth-first traversal in order to invalidate everything.
205  */
206 STATIC int
207 xfs_attr3_node_inactive(
208 	struct xfs_trans **trans,
209 	struct xfs_inode *dp,
210 	struct xfs_buf	*bp,
211 	int		level)
212 {
213 	xfs_da_blkinfo_t *info;
214 	xfs_da_intnode_t *node;
215 	xfs_dablk_t child_fsb;
216 	xfs_daddr_t parent_blkno, child_blkno;
217 	int error, i;
218 	struct xfs_buf *child_bp;
219 	struct xfs_da_node_entry *btree;
220 	struct xfs_da3_icnode_hdr ichdr;
221 
222 	/*
223 	 * Since this code is recursive (gasp!) we must protect ourselves.
224 	 */
225 	if (level > XFS_DA_NODE_MAXDEPTH) {
226 		xfs_trans_brelse(*trans, bp);	/* no locks for later trans */
227 		return -EIO;
228 	}
229 
230 	node = bp->b_addr;
231 	dp->d_ops->node_hdr_from_disk(&ichdr, node);
232 	parent_blkno = bp->b_bn;
233 	if (!ichdr.count) {
234 		xfs_trans_brelse(*trans, bp);
235 		return 0;
236 	}
237 	btree = dp->d_ops->node_tree_p(node);
238 	child_fsb = be32_to_cpu(btree[0].before);
239 	xfs_trans_brelse(*trans, bp);	/* no locks for later trans */
240 
241 	/*
242 	 * If this is the node level just above the leaves, simply loop
243 	 * over the leaves removing all of them.  If this is higher up
244 	 * in the tree, recurse downward.
245 	 */
246 	for (i = 0; i < ichdr.count; i++) {
247 		/*
248 		 * Read the subsidiary block to see what we have to work with.
249 		 * Don't do this in a transaction.  This is a depth-first
250 		 * traversal of the tree so we may deal with many blocks
251 		 * before we come back to this one.
252 		 */
253 		error = xfs_da3_node_read(*trans, dp, child_fsb, -2, &child_bp,
254 						XFS_ATTR_FORK);
255 		if (error)
256 			return error;
257 		if (child_bp) {
258 						/* save for re-read later */
259 			child_blkno = XFS_BUF_ADDR(child_bp);
260 
261 			/*
262 			 * Invalidate the subtree, however we have to.
263 			 */
264 			info = child_bp->b_addr;
265 			switch (info->magic) {
266 			case cpu_to_be16(XFS_DA_NODE_MAGIC):
267 			case cpu_to_be16(XFS_DA3_NODE_MAGIC):
268 				error = xfs_attr3_node_inactive(trans, dp,
269 							child_bp, level + 1);
270 				break;
271 			case cpu_to_be16(XFS_ATTR_LEAF_MAGIC):
272 			case cpu_to_be16(XFS_ATTR3_LEAF_MAGIC):
273 				error = xfs_attr3_leaf_inactive(trans, dp,
274 							child_bp);
275 				break;
276 			default:
277 				error = -EIO;
278 				xfs_trans_brelse(*trans, child_bp);
279 				break;
280 			}
281 			if (error)
282 				return error;
283 
284 			/*
285 			 * Remove the subsidiary block from the cache
286 			 * and from the log.
287 			 */
288 			error = xfs_da_get_buf(*trans, dp, 0, child_blkno,
289 				&child_bp, XFS_ATTR_FORK);
290 			if (error)
291 				return error;
292 			xfs_trans_binval(*trans, child_bp);
293 		}
294 
295 		/*
296 		 * If we're not done, re-read the parent to get the next
297 		 * child block number.
298 		 */
299 		if (i + 1 < ichdr.count) {
300 			error = xfs_da3_node_read(*trans, dp, 0, parent_blkno,
301 						 &bp, XFS_ATTR_FORK);
302 			if (error)
303 				return error;
304 			child_fsb = be32_to_cpu(btree[i + 1].before);
305 			xfs_trans_brelse(*trans, bp);
306 		}
307 		/*
308 		 * Atomically commit the whole invalidate stuff.
309 		 */
310 		error = xfs_trans_roll(trans, dp);
311 		if (error)
312 			return  error;
313 	}
314 
315 	return 0;
316 }
317 
318 /*
319  * Indiscriminately delete the entire attribute fork
320  *
321  * Recurse (gasp!) through the attribute nodes until we find leaves.
322  * We're doing a depth-first traversal in order to invalidate everything.
323  */
324 int
325 xfs_attr3_root_inactive(
326 	struct xfs_trans	**trans,
327 	struct xfs_inode	*dp)
328 {
329 	struct xfs_da_blkinfo	*info;
330 	struct xfs_buf		*bp;
331 	xfs_daddr_t		blkno;
332 	int			error;
333 
334 	/*
335 	 * Read block 0 to see what we have to work with.
336 	 * We only get here if we have extents, since we remove
337 	 * the extents in reverse order the extent containing
338 	 * block 0 must still be there.
339 	 */
340 	error = xfs_da3_node_read(*trans, dp, 0, -1, &bp, XFS_ATTR_FORK);
341 	if (error)
342 		return error;
343 	blkno = bp->b_bn;
344 
345 	/*
346 	 * Invalidate the tree, even if the "tree" is only a single leaf block.
347 	 * This is a depth-first traversal!
348 	 */
349 	info = bp->b_addr;
350 	switch (info->magic) {
351 	case cpu_to_be16(XFS_DA_NODE_MAGIC):
352 	case cpu_to_be16(XFS_DA3_NODE_MAGIC):
353 		error = xfs_attr3_node_inactive(trans, dp, bp, 1);
354 		break;
355 	case cpu_to_be16(XFS_ATTR_LEAF_MAGIC):
356 	case cpu_to_be16(XFS_ATTR3_LEAF_MAGIC):
357 		error = xfs_attr3_leaf_inactive(trans, dp, bp);
358 		break;
359 	default:
360 		error = -EIO;
361 		xfs_trans_brelse(*trans, bp);
362 		break;
363 	}
364 	if (error)
365 		return error;
366 
367 	/*
368 	 * Invalidate the incore copy of the root block.
369 	 */
370 	error = xfs_da_get_buf(*trans, dp, 0, blkno, &bp, XFS_ATTR_FORK);
371 	if (error)
372 		return error;
373 	xfs_trans_binval(*trans, bp);	/* remove from cache */
374 	/*
375 	 * Commit the invalidate and start the next transaction.
376 	 */
377 	error = xfs_trans_roll(trans, dp);
378 
379 	return error;
380 }
381 
382 int
383 xfs_attr_inactive(xfs_inode_t *dp)
384 {
385 	xfs_trans_t *trans;
386 	xfs_mount_t *mp;
387 	int error;
388 
389 	mp = dp->i_mount;
390 	ASSERT(! XFS_NOT_DQATTACHED(mp, dp));
391 
392 	xfs_ilock(dp, XFS_ILOCK_SHARED);
393 	if (!xfs_inode_hasattr(dp) ||
394 	    dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
395 		xfs_iunlock(dp, XFS_ILOCK_SHARED);
396 		return 0;
397 	}
398 	xfs_iunlock(dp, XFS_ILOCK_SHARED);
399 
400 	/*
401 	 * Start our first transaction of the day.
402 	 *
403 	 * All future transactions during this code must be "chained" off
404 	 * this one via the trans_dup() call.  All transactions will contain
405 	 * the inode, and the inode will always be marked with trans_ihold().
406 	 * Since the inode will be locked in all transactions, we must log
407 	 * the inode in every transaction to let it float upward through
408 	 * the log.
409 	 */
410 	trans = xfs_trans_alloc(mp, XFS_TRANS_ATTRINVAL);
411 	error = xfs_trans_reserve(trans, &M_RES(mp)->tr_attrinval, 0, 0);
412 	if (error) {
413 		xfs_trans_cancel(trans, 0);
414 		return error;
415 	}
416 	xfs_ilock(dp, XFS_ILOCK_EXCL);
417 
418 	/*
419 	 * No need to make quota reservations here. We expect to release some
420 	 * blocks, not allocate, in the common case.
421 	 */
422 	xfs_trans_ijoin(trans, dp, 0);
423 
424 	/*
425 	 * Decide on what work routines to call based on the inode size.
426 	 */
427 	if (!xfs_inode_hasattr(dp) ||
428 	    dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
429 		error = 0;
430 		goto out;
431 	}
432 	error = xfs_attr3_root_inactive(&trans, dp);
433 	if (error)
434 		goto out;
435 
436 	error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0);
437 	if (error)
438 		goto out;
439 
440 	error = xfs_trans_commit(trans, XFS_TRANS_RELEASE_LOG_RES);
441 	xfs_iunlock(dp, XFS_ILOCK_EXCL);
442 
443 	return error;
444 
445 out:
446 	xfs_trans_cancel(trans, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
447 	xfs_iunlock(dp, XFS_ILOCK_EXCL);
448 	return error;
449 }
450