projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xfs: decouple log and transaction headers
[deliverable/linux.git] / fs / xfs / xfs_symlink.c
1 /*
2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3 * Copyright (c) 2012-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_shared.h"
21 #include "xfs_fs.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_sb.h"
27 #include "xfs_ag.h"
28 #include "xfs_mount.h"
29 #include "xfs_da_format.h"
30 #include "xfs_dir2.h"
31 #include "xfs_bmap_btree.h"
32 #include "xfs_ialloc_btree.h"
33 #include "xfs_dinode.h"
34 #include "xfs_inode.h"
35 #include "xfs_ialloc.h"
36 #include "xfs_alloc.h"
37 #include "xfs_bmap.h"
38 #include "xfs_bmap_util.h"
39 #include "xfs_error.h"
40 #include "xfs_quota.h"
41 #include "xfs_trans_space.h"
42 #include "xfs_trace.h"
43 #include "xfs_symlink.h"
44 #include "xfs_trans.h"
45 #include "xfs_buf_item.h"
46 #include "xfs_log.h"
47
48 /* ----- Kernel only functions below ----- */
49 STATIC int
50 xfs_readlink_bmap(
51 struct xfs_inode *ip,
52 char *link)
53 {
54 struct xfs_mount *mp = ip->i_mount;
55 struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS];
56 struct xfs_buf *bp;
57 xfs_daddr_t d;
58 char *cur_chunk;
59 int pathlen = ip->i_d.di_size;
60 int nmaps = XFS_SYMLINK_MAPS;
61 int byte_cnt;
62 int n;
63 int error = 0;
64 int fsblocks = 0;
65 int offset;
66
67 fsblocks = xfs_symlink_blocks(mp, pathlen);
68 error = xfs_bmapi_read(ip, 0, fsblocks, mval, &nmaps, 0);
69 if (error)
70 goto out;
71
72 offset = 0;
73 for (n = 0; n < nmaps; n++) {
74 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
75 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
76
77 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0,
78 &xfs_symlink_buf_ops);
79 if (!bp)
80 return XFS_ERROR(ENOMEM);
81 error = bp->b_error;
82 if (error) {
83 xfs_buf_ioerror_alert(bp, __func__);
84 xfs_buf_relse(bp);
85 goto out;
86 }
87 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
88 if (pathlen < byte_cnt)
89 byte_cnt = pathlen;
90
91 cur_chunk = bp->b_addr;
92 if (xfs_sb_version_hascrc(&mp->m_sb)) {
93 if (!xfs_symlink_hdr_ok(mp, ip->i_ino, offset,
94 byte_cnt, bp)) {
95 error = EFSCORRUPTED;
96 xfs_alert(mp,
97 "symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)",
98 offset, byte_cnt, ip->i_ino);
99 xfs_buf_relse(bp);
100 goto out;
101
102 }
103
104 cur_chunk += sizeof(struct xfs_dsymlink_hdr);
105 }
106
107 memcpy(link + offset, bp->b_addr, byte_cnt);
108
109 pathlen -= byte_cnt;
110 offset += byte_cnt;
111
112 xfs_buf_relse(bp);
113 }
114 ASSERT(pathlen == 0);
115
116 link[ip->i_d.di_size] = '\0';
117 error = 0;
118
119 out:
120 return error;
121 }
122
123 int
124 xfs_readlink(
125 struct xfs_inode *ip,
126 char *link)
127 {
128 struct xfs_mount *mp = ip->i_mount;
129 xfs_fsize_t pathlen;
130 int error = 0;
131
132 trace_xfs_readlink(ip);
133
134 if (XFS_FORCED_SHUTDOWN(mp))
135 return XFS_ERROR(EIO);
136
137 xfs_ilock(ip, XFS_ILOCK_SHARED);
138
139 pathlen = ip->i_d.di_size;
140 if (!pathlen)
141 goto out;
142
143 if (pathlen < 0 || pathlen > MAXPATHLEN) {
144 xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
145 __func__, (unsigned long long) ip->i_ino,
146 (long long) pathlen);
147 ASSERT(0);
148 error = XFS_ERROR(EFSCORRUPTED);
149 goto out;
150 }
151
152
153 if (ip->i_df.if_flags & XFS_IFINLINE) {
154 memcpy(link, ip->i_df.if_u1.if_data, pathlen);
155 link[pathlen] = '\0';
156 } else {
157 error = xfs_readlink_bmap(ip, link);
158 }
159
160 out:
161 xfs_iunlock(ip, XFS_ILOCK_SHARED);
162 return error;
163 }
164
165 int
166 xfs_symlink(
167 struct xfs_inode *dp,
168 struct xfs_name *link_name,
169 const char *target_path,
170 umode_t mode,
171 struct xfs_inode **ipp)
172 {
173 struct xfs_mount *mp = dp->i_mount;
174 struct xfs_trans *tp = NULL;
175 struct xfs_inode *ip = NULL;
176 int error = 0;
177 int pathlen;
178 struct xfs_bmap_free free_list;
179 xfs_fsblock_t first_block;
180 bool unlock_dp_on_error = false;
181 uint cancel_flags;
182 int committed;
183 xfs_fileoff_t first_fsb;
184 xfs_filblks_t fs_blocks;
185 int nmaps;
186 struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS];
187 xfs_daddr_t d;
188 const char *cur_chunk;
189 int byte_cnt;
190 int n;
191 xfs_buf_t *bp;
192 prid_t prid;
193 struct xfs_dquot *udqp = NULL;
194 struct xfs_dquot *gdqp = NULL;
195 struct xfs_dquot *pdqp = NULL;
196 uint resblks;
197
198 *ipp = NULL;
199
200 trace_xfs_symlink(dp, link_name);
201
202 if (XFS_FORCED_SHUTDOWN(mp))
203 return XFS_ERROR(EIO);
204
205 /*
206 * Check component lengths of the target path name.
207 */
208 pathlen = strlen(target_path);
209 if (pathlen >= MAXPATHLEN) /* total string too long */
210 return XFS_ERROR(ENAMETOOLONG);
211
212 udqp = gdqp = NULL;
213 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
214 prid = xfs_get_projid(dp);
215 else
216 prid = XFS_PROJID_DEFAULT;
217
218 /*
219 * Make sure that we have allocated dquot(s) on disk.
220 */
221 error = xfs_qm_vop_dqalloc(dp,
222 xfs_kuid_to_uid(current_fsuid()),
223 xfs_kgid_to_gid(current_fsgid()), prid,
224 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
225 &udqp, &gdqp, &pdqp);
226 if (error)
227 goto std_return;
228
229 tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
230 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
231 /*
232 * The symlink will fit into the inode data fork?
233 * There can't be any attributes so we get the whole variable part.
234 */
235 if (pathlen <= XFS_LITINO(mp, dp->i_d.di_version))
236 fs_blocks = 0;
237 else
238 fs_blocks = xfs_symlink_blocks(mp, pathlen);
239 resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
240 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, resblks, 0);
241 if (error == ENOSPC && fs_blocks == 0) {
242 resblks = 0;
243 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, 0, 0);
244 }
245 if (error) {
246 cancel_flags = 0;
247 goto error_return;
248 }
249
250 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
251 unlock_dp_on_error = true;
252
253 /*
254 * Check whether the directory allows new symlinks or not.
255 */
256 if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
257 error = XFS_ERROR(EPERM);
258 goto error_return;
259 }
260
261 /*
262 * Reserve disk quota : blocks and inode.
263 */
264 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
265 pdqp, resblks, 1, 0);
266 if (error)
267 goto error_return;
268
269 /*
270 * Check for ability to enter directory entry, if no space reserved.
271 */
272 error = xfs_dir_canenter(tp, dp, link_name, resblks);
273 if (error)
274 goto error_return;
275 /*
276 * Initialize the bmap freelist prior to calling either
277 * bmapi or the directory create code.
278 */
279 xfs_bmap_init(&free_list, &first_block);
280
281 /*
282 * Allocate an inode for the symlink.
283 */
284 error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
285 prid, resblks > 0, &ip, NULL);
286 if (error) {
287 if (error == ENOSPC)
288 goto error_return;
289 goto error1;
290 }
291
292 /*
293 * An error after we've joined dp to the transaction will result in the
294 * transaction cancel unlocking dp so don't do it explicitly in the
295 * error path.
296 */
297 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
298 unlock_dp_on_error = false;
299
300 /*
301 * Also attach the dquot(s) to it, if applicable.
302 */
303 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
304
305 if (resblks)
306 resblks -= XFS_IALLOC_SPACE_RES(mp);
307 /*
308 * If the symlink will fit into the inode, write it inline.
309 */
310 if (pathlen <= XFS_IFORK_DSIZE(ip)) {
311 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
312 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
313 ip->i_d.di_size = pathlen;
314
315 /*
316 * The inode was initially created in extent format.
317 */
318 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
319 ip->i_df.if_flags |= XFS_IFINLINE;
320
321 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
322 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
323
324 } else {
325 int offset;
326
327 first_fsb = 0;
328 nmaps = XFS_SYMLINK_MAPS;
329
330 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
331 XFS_BMAPI_METADATA, &first_block, resblks,
332 mval, &nmaps, &free_list);
333 if (error)
334 goto error2;
335
336 if (resblks)
337 resblks -= fs_blocks;
338 ip->i_d.di_size = pathlen;
339 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
340
341 cur_chunk = target_path;
342 offset = 0;
343 for (n = 0; n < nmaps; n++) {
344 char *buf;
345
346 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
347 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
348 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
349 BTOBB(byte_cnt), 0);
350 if (!bp) {
351 error = ENOMEM;
352 goto error2;
353 }
354 bp->b_ops = &xfs_symlink_buf_ops;
355
356 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
357 byte_cnt = min(byte_cnt, pathlen);
358
359 buf = bp->b_addr;
360 buf += xfs_symlink_hdr_set(mp, ip->i_ino, offset,
361 byte_cnt, bp);
362
363 memcpy(buf, cur_chunk, byte_cnt);
364
365 cur_chunk += byte_cnt;
366 pathlen -= byte_cnt;
367 offset += byte_cnt;
368
369 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);
370 xfs_trans_log_buf(tp, bp, 0, (buf + byte_cnt - 1) -
371 (char *)bp->b_addr);
372 }
373 ASSERT(pathlen == 0);
374 }
375
376 /*
377 * Create the directory entry for the symlink.
378 */
379 error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
380 &first_block, &free_list, resblks);
381 if (error)
382 goto error2;
383 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
384 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
385
386 /*
387 * If this is a synchronous mount, make sure that the
388 * symlink transaction goes to disk before returning to
389 * the user.
390 */
391 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
392 xfs_trans_set_sync(tp);
393 }
394
395 error = xfs_bmap_finish(&tp, &free_list, &committed);
396 if (error) {
397 goto error2;
398 }
399 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
400 xfs_qm_dqrele(udqp);
401 xfs_qm_dqrele(gdqp);
402 xfs_qm_dqrele(pdqp);
403
404 *ipp = ip;
405 return 0;
406
407 error2:
408 IRELE(ip);
409 error1:
410 xfs_bmap_cancel(&free_list);
411 cancel_flags |= XFS_TRANS_ABORT;
412 error_return:
413 xfs_trans_cancel(tp, cancel_flags);
414 xfs_qm_dqrele(udqp);
415 xfs_qm_dqrele(gdqp);
416 xfs_qm_dqrele(pdqp);
417
418 if (unlock_dp_on_error)
419 xfs_iunlock(dp, XFS_ILOCK_EXCL);
420 std_return:
421 return error;
422 }
423
424 /*
425 * Free a symlink that has blocks associated with it.
426 */
427 STATIC int
428 xfs_inactive_symlink_rmt(
429 struct xfs_inode *ip)
430 {
431 xfs_buf_t *bp;
432 int committed;
433 int done;
434 int error;
435 xfs_fsblock_t first_block;
436 xfs_bmap_free_t free_list;
437 int i;
438 xfs_mount_t *mp;
439 xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS];
440 int nmaps;
441 int size;
442 xfs_trans_t *tp;
443
444 mp = ip->i_mount;
445 ASSERT(ip->i_df.if_flags & XFS_IFEXTENTS);
446 /*
447 * We're freeing a symlink that has some
448 * blocks allocated to it. Free the
449 * blocks here. We know that we've got
450 * either 1 or 2 extents and that we can
451 * free them all in one bunmapi call.
452 */
453 ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
454
455 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
456 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
457 if (error) {
458 xfs_trans_cancel(tp, 0);
459 return error;
460 }
461
462 xfs_ilock(ip, XFS_ILOCK_EXCL);
463 xfs_trans_ijoin(tp, ip, 0);
464
465 /*
466 * Lock the inode, fix the size, and join it to the transaction.
467 * Hold it so in the normal path, we still have it locked for
468 * the second transaction. In the error paths we need it
469 * held so the cancel won't rele it, see below.
470 */
471 size = (int)ip->i_d.di_size;
472 ip->i_d.di_size = 0;
473 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
474 /*
475 * Find the block(s) so we can inval and unmap them.
476 */
477 done = 0;
478 xfs_bmap_init(&free_list, &first_block);
479 nmaps = ARRAY_SIZE(mval);
480 error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size),
481 mval, &nmaps, 0);
482 if (error)
483 goto error_trans_cancel;
484 /*
485 * Invalidate the block(s). No validation is done.
486 */
487 for (i = 0; i < nmaps; i++) {
488 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
489 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
490 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
491 if (!bp) {
492 error = ENOMEM;
493 goto error_bmap_cancel;
494 }
495 xfs_trans_binval(tp, bp);
496 }
497 /*
498 * Unmap the dead block(s) to the free_list.
499 */
500 error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
501 &first_block, &free_list, &done);
502 if (error)
503 goto error_bmap_cancel;
504 ASSERT(done);
505 /*
506 * Commit the first transaction. This logs the EFI and the inode.
507 */
508 error = xfs_bmap_finish(&tp, &free_list, &committed);
509 if (error)
510 goto error_bmap_cancel;
511 /*
512 * The transaction must have been committed, since there were
513 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
514 * The new tp has the extent freeing and EFDs.
515 */
516 ASSERT(committed);
517 /*
518 * The first xact was committed, so add the inode to the new one.
519 * Mark it dirty so it will be logged and moved forward in the log as
520 * part of every commit.
521 */
522 xfs_trans_ijoin(tp, ip, 0);
523 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
524 /*
525 * Commit the transaction containing extent freeing and EFDs.
526 */
527 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
528 if (error) {
529 ASSERT(XFS_FORCED_SHUTDOWN(mp));
530 goto error_unlock;
531 }
532
533 /*
534 * Remove the memory for extent descriptions (just bookkeeping).
535 */
536 if (ip->i_df.if_bytes)
537 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
538 ASSERT(ip->i_df.if_bytes == 0);
539
540 xfs_iunlock(ip, XFS_ILOCK_EXCL);
541 return 0;
542
543 error_bmap_cancel:
544 xfs_bmap_cancel(&free_list);
545 error_trans_cancel:
546 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
547 error_unlock:
548 xfs_iunlock(ip, XFS_ILOCK_EXCL);
549 return error;
550 }
551
552 /*
553 * xfs_inactive_symlink - free a symlink
554 */
555 int
556 xfs_inactive_symlink(
557 struct xfs_inode *ip)
558 {
559 struct xfs_mount *mp = ip->i_mount;
560 int pathlen;
561
562 trace_xfs_inactive_symlink(ip);
563
564 if (XFS_FORCED_SHUTDOWN(mp))
565 return XFS_ERROR(EIO);
566
567 xfs_ilock(ip, XFS_ILOCK_EXCL);
568
569 /*
570 * Zero length symlinks _can_ exist.
571 */
572 pathlen = (int)ip->i_d.di_size;
573 if (!pathlen) {
574 xfs_iunlock(ip, XFS_ILOCK_EXCL);
575 return 0;
576 }
577
578 if (pathlen < 0 || pathlen > MAXPATHLEN) {
579 xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)",
580 __func__, (unsigned long long)ip->i_ino, pathlen);
581 xfs_iunlock(ip, XFS_ILOCK_EXCL);
582 ASSERT(0);
583 return XFS_ERROR(EFSCORRUPTED);
584 }
585
586 if (ip->i_df.if_flags & XFS_IFINLINE) {
587 if (ip->i_df.if_bytes > 0)
588 xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
589 XFS_DATA_FORK);
590 xfs_iunlock(ip, XFS_ILOCK_EXCL);
591 ASSERT(ip->i_df.if_bytes == 0);
592 return 0;
593 }
594
595 xfs_iunlock(ip, XFS_ILOCK_EXCL);
596
597 /* remove the remote symlink */
598 return xfs_inactive_symlink_rmt(ip);
599 }
Linux kernel - Deliverables
This page took 0.043713 seconds and 5 git commands to generate.