1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include "xfs.h"
20#include "xfs_fs.h"
21#include "xfs_format.h"
22#include "xfs_bit.h"
23#include "xfs_log.h"
24#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
27#include "xfs_mount.h"
28#include "xfs_da_btree.h"
29#include "xfs_dir2_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_buf_item.h"
45
46
47STATIC int
48xfs_readlink_bmap(
49 struct xfs_inode *ip,
50 char *link)
51{
52 struct xfs_mount *mp = ip->i_mount;
53 struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS];
54 struct xfs_buf *bp;
55 xfs_daddr_t d;
56 char *cur_chunk;
57 int pathlen = ip->i_d.di_size;
58 int nmaps = XFS_SYMLINK_MAPS;
59 int byte_cnt;
60 int n;
61 int error = 0;
62 int fsblocks = 0;
63 int offset;
64
65 fsblocks = xfs_symlink_blocks(mp, pathlen);
66 error = xfs_bmapi_read(ip, 0, fsblocks, mval, &nmaps, 0);
67 if (error)
68 goto out;
69
70 offset = 0;
71 for (n = 0; n < nmaps; n++) {
72 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
73 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
74
75 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0,
76 &xfs_symlink_buf_ops);
77 if (!bp)
78 return XFS_ERROR(ENOMEM);
79 error = bp->b_error;
80 if (error) {
81 xfs_buf_ioerror_alert(bp, __func__);
82 xfs_buf_relse(bp);
83 goto out;
84 }
85 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
86 if (pathlen < byte_cnt)
87 byte_cnt = pathlen;
88
89 cur_chunk = bp->b_addr;
90 if (xfs_sb_version_hascrc(&mp->m_sb)) {
91 if (!xfs_symlink_hdr_ok(mp, ip->i_ino, offset,
92 byte_cnt, bp)) {
93 error = EFSCORRUPTED;
94 xfs_alert(mp,
95"symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)",
96 offset, byte_cnt, ip->i_ino);
97 xfs_buf_relse(bp);
98 goto out;
99
100 }
101
102 cur_chunk += sizeof(struct xfs_dsymlink_hdr);
103 }
104
105 memcpy(link + offset, bp->b_addr, byte_cnt);
106
107 pathlen -= byte_cnt;
108 offset += byte_cnt;
109
110 xfs_buf_relse(bp);
111 }
112 ASSERT(pathlen == 0);
113
114 link[ip->i_d.di_size] = '\0';
115 error = 0;
116
117 out:
118 return error;
119}
120
121int
122xfs_readlink(
123 struct xfs_inode *ip,
124 char *link)
125{
126 struct xfs_mount *mp = ip->i_mount;
127 xfs_fsize_t pathlen;
128 int error = 0;
129
130 trace_xfs_readlink(ip);
131
132 if (XFS_FORCED_SHUTDOWN(mp))
133 return XFS_ERROR(EIO);
134
135 xfs_ilock(ip, XFS_ILOCK_SHARED);
136
137 pathlen = ip->i_d.di_size;
138 if (!pathlen)
139 goto out;
140
141 if (pathlen < 0 || pathlen > MAXPATHLEN) {
142 xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
143 __func__, (unsigned long long) ip->i_ino,
144 (long long) pathlen);
145 ASSERT(0);
146 error = XFS_ERROR(EFSCORRUPTED);
147 goto out;
148 }
149
150
151 if (ip->i_df.if_flags & XFS_IFINLINE) {
152 memcpy(link, ip->i_df.if_u1.if_data, pathlen);
153 link[pathlen] = '\0';
154 } else {
155 error = xfs_readlink_bmap(ip, link);
156 }
157
158 out:
159 xfs_iunlock(ip, XFS_ILOCK_SHARED);
160 return error;
161}
162
163int
164xfs_symlink(
165 struct xfs_inode *dp,
166 struct xfs_name *link_name,
167 const char *target_path,
168 umode_t mode,
169 struct xfs_inode **ipp)
170{
171 struct xfs_mount *mp = dp->i_mount;
172 struct xfs_trans *tp = NULL;
173 struct xfs_inode *ip = NULL;
174 int error = 0;
175 int pathlen;
176 struct xfs_bmap_free free_list;
177 xfs_fsblock_t first_block;
178 bool unlock_dp_on_error = false;
179 uint cancel_flags;
180 int committed;
181 xfs_fileoff_t first_fsb;
182 xfs_filblks_t fs_blocks;
183 int nmaps;
184 struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS];
185 xfs_daddr_t d;
186 const char *cur_chunk;
187 int byte_cnt;
188 int n;
189 xfs_buf_t *bp;
190 prid_t prid;
191 struct xfs_dquot *udqp = NULL;
192 struct xfs_dquot *gdqp = NULL;
193 struct xfs_dquot *pdqp = NULL;
194 uint resblks;
195
196 *ipp = NULL;
197
198 trace_xfs_symlink(dp, link_name);
199
200 if (XFS_FORCED_SHUTDOWN(mp))
201 return XFS_ERROR(EIO);
202
203
204
205
206 pathlen = strlen(target_path);
207 if (pathlen >= MAXPATHLEN)
208 return XFS_ERROR(ENAMETOOLONG);
209
210 udqp = gdqp = NULL;
211 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
212 prid = xfs_get_projid(dp);
213 else
214 prid = XFS_PROJID_DEFAULT;
215
216
217
218
219 error = xfs_qm_vop_dqalloc(dp,
220 xfs_kuid_to_uid(current_fsuid()),
221 xfs_kgid_to_gid(current_fsgid()), prid,
222 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
223 &udqp, &gdqp, &pdqp);
224 if (error)
225 goto std_return;
226
227 tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
228 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
229
230
231
232
233 if (pathlen <= XFS_LITINO(mp, dp->i_d.di_version))
234 fs_blocks = 0;
235 else
236 fs_blocks = xfs_symlink_blocks(mp, pathlen);
237 resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
238 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, resblks, 0);
239 if (error == ENOSPC && fs_blocks == 0) {
240 resblks = 0;
241 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, 0, 0);
242 }
243 if (error) {
244 cancel_flags = 0;
245 goto error_return;
246 }
247
248 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
249 unlock_dp_on_error = true;
250
251
252
253
254 if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
255 error = XFS_ERROR(EPERM);
256 goto error_return;
257 }
258
259
260
261
262 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
263 pdqp, resblks, 1, 0);
264 if (error)
265 goto error_return;
266
267
268
269
270 error = xfs_dir_canenter(tp, dp, link_name, resblks);
271 if (error)
272 goto error_return;
273
274
275
276
277 xfs_bmap_init(&free_list, &first_block);
278
279
280
281
282 error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
283 prid, resblks > 0, &ip, NULL);
284 if (error) {
285 if (error == ENOSPC)
286 goto error_return;
287 goto error1;
288 }
289
290
291
292
293
294
295 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
296 unlock_dp_on_error = false;
297
298
299
300
301 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
302
303 if (resblks)
304 resblks -= XFS_IALLOC_SPACE_RES(mp);
305
306
307
308 if (pathlen <= XFS_IFORK_DSIZE(ip)) {
309 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
310 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
311 ip->i_d.di_size = pathlen;
312
313
314
315
316 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
317 ip->i_df.if_flags |= XFS_IFINLINE;
318
319 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
320 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
321
322 } else {
323 int offset;
324
325 first_fsb = 0;
326 nmaps = XFS_SYMLINK_MAPS;
327
328 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
329 XFS_BMAPI_METADATA, &first_block, resblks,
330 mval, &nmaps, &free_list);
331 if (error)
332 goto error2;
333
334 if (resblks)
335 resblks -= fs_blocks;
336 ip->i_d.di_size = pathlen;
337 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
338
339 cur_chunk = target_path;
340 offset = 0;
341 for (n = 0; n < nmaps; n++) {
342 char *buf;
343
344 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
345 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
346 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
347 BTOBB(byte_cnt), 0);
348 if (!bp) {
349 error = ENOMEM;
350 goto error2;
351 }
352 bp->b_ops = &xfs_symlink_buf_ops;
353
354 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
355 byte_cnt = min(byte_cnt, pathlen);
356
357 buf = bp->b_addr;
358 buf += xfs_symlink_hdr_set(mp, ip->i_ino, offset,
359 byte_cnt, bp);
360
361 memcpy(buf, cur_chunk, byte_cnt);
362
363 cur_chunk += byte_cnt;
364 pathlen -= byte_cnt;
365 offset += byte_cnt;
366
367 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);
368 xfs_trans_log_buf(tp, bp, 0, (buf + byte_cnt - 1) -
369 (char *)bp->b_addr);
370 }
371 ASSERT(pathlen == 0);
372 }
373
374
375
376
377 error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
378 &first_block, &free_list, resblks);
379 if (error)
380 goto error2;
381 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
382 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
383
384
385
386
387
388
389 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
390 xfs_trans_set_sync(tp);
391 }
392
393 error = xfs_bmap_finish(&tp, &free_list, &committed);
394 if (error) {
395 goto error2;
396 }
397 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
398 xfs_qm_dqrele(udqp);
399 xfs_qm_dqrele(gdqp);
400 xfs_qm_dqrele(pdqp);
401
402 *ipp = ip;
403 return 0;
404
405 error2:
406 IRELE(ip);
407 error1:
408 xfs_bmap_cancel(&free_list);
409 cancel_flags |= XFS_TRANS_ABORT;
410 error_return:
411 xfs_trans_cancel(tp, cancel_flags);
412 xfs_qm_dqrele(udqp);
413 xfs_qm_dqrele(gdqp);
414 xfs_qm_dqrele(pdqp);
415
416 if (unlock_dp_on_error)
417 xfs_iunlock(dp, XFS_ILOCK_EXCL);
418 std_return:
419 return error;
420}
421
422
423
424
425STATIC int
426xfs_inactive_symlink_rmt(
427 xfs_inode_t *ip,
428 xfs_trans_t **tpp)
429{
430 xfs_buf_t *bp;
431 int committed;
432 int done;
433 int error;
434 xfs_fsblock_t first_block;
435 xfs_bmap_free_t free_list;
436 int i;
437 xfs_mount_t *mp;
438 xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS];
439 int nmaps;
440 xfs_trans_t *ntp;
441 int size;
442 xfs_trans_t *tp;
443
444 tp = *tpp;
445 mp = ip->i_mount;
446 ASSERT(ip->i_df.if_flags & XFS_IFEXTENTS);
447
448
449
450
451
452
453
454 ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
455
456
457
458
459
460
461
462 size = (int)ip->i_d.di_size;
463 ip->i_d.di_size = 0;
464 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
465
466
467
468 done = 0;
469 xfs_bmap_init(&free_list, &first_block);
470 nmaps = ARRAY_SIZE(mval);
471 error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size),
472 mval, &nmaps, 0);
473 if (error)
474 goto error0;
475
476
477
478 for (i = 0; i < nmaps; i++) {
479 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
480 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
481 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
482 if (!bp) {
483 error = ENOMEM;
484 goto error1;
485 }
486 xfs_trans_binval(tp, bp);
487 }
488
489
490
491 if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
492 &first_block, &free_list, &done)))
493 goto error1;
494 ASSERT(done);
495
496
497
498 if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
499 goto error1;
500
501
502
503
504
505 ASSERT(committed);
506
507
508
509
510
511 xfs_trans_ijoin(tp, ip, 0);
512 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
513
514
515
516 ntp = xfs_trans_dup(tp);
517
518
519
520
521
522
523 error = xfs_trans_commit(tp, 0);
524 tp = ntp;
525 if (error) {
526 ASSERT(XFS_FORCED_SHUTDOWN(mp));
527 goto error0;
528 }
529
530
531
532
533 xfs_log_ticket_put(tp->t_ticket);
534
535
536
537
538 if (ip->i_df.if_bytes)
539 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
540 ASSERT(ip->i_df.if_bytes == 0);
541
542
543
544
545 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
546 if (error) {
547 ASSERT(XFS_FORCED_SHUTDOWN(mp));
548 goto error0;
549 }
550
551 xfs_trans_ijoin(tp, ip, 0);
552 *tpp = tp;
553 return 0;
554
555 error1:
556 xfs_bmap_cancel(&free_list);
557 error0:
558 return error;
559}
560
561
562
563
564int
565xfs_inactive_symlink(
566 struct xfs_inode *ip,
567 struct xfs_trans **tp)
568{
569 struct xfs_mount *mp = ip->i_mount;
570 int pathlen;
571
572 trace_xfs_inactive_symlink(ip);
573
574 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
575
576 if (XFS_FORCED_SHUTDOWN(mp))
577 return XFS_ERROR(EIO);
578
579
580
581
582 pathlen = (int)ip->i_d.di_size;
583 if (!pathlen)
584 return 0;
585
586 if (pathlen < 0 || pathlen > MAXPATHLEN) {
587 xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)",
588 __func__, (unsigned long long)ip->i_ino, pathlen);
589 ASSERT(0);
590 return XFS_ERROR(EFSCORRUPTED);
591 }
592
593 if (ip->i_df.if_flags & XFS_IFINLINE) {
594 if (ip->i_df.if_bytes > 0)
595 xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
596 XFS_DATA_FORK);
597 ASSERT(ip->i_df.if_bytes == 0);
598 return 0;
599 }
600
601
602 return xfs_inactive_symlink_rmt(ip, tp);
603}
604