GNU Linux-libre 5.19-rc6-gnu
[releases.git] / fs / xfs / xfs_symlink.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
4  * Copyright (c) 2012-2013 Red Hat, Inc.
5  * All rights reserved.
6  */
7 #include "xfs.h"
8 #include "xfs_shared.h"
9 #include "xfs_fs.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_dir2.h"
16 #include "xfs_inode.h"
17 #include "xfs_bmap.h"
18 #include "xfs_bmap_btree.h"
19 #include "xfs_quota.h"
20 #include "xfs_symlink.h"
21 #include "xfs_trans_space.h"
22 #include "xfs_trace.h"
23 #include "xfs_trans.h"
24 #include "xfs_ialloc.h"
25 #include "xfs_error.h"
26
27 /* ----- Kernel only functions below ----- */
28 int
29 xfs_readlink_bmap_ilocked(
30         struct xfs_inode        *ip,
31         char                    *link)
32 {
33         struct xfs_mount        *mp = ip->i_mount;
34         struct xfs_bmbt_irec    mval[XFS_SYMLINK_MAPS];
35         struct xfs_buf          *bp;
36         xfs_daddr_t             d;
37         char                    *cur_chunk;
38         int                     pathlen = ip->i_disk_size;
39         int                     nmaps = XFS_SYMLINK_MAPS;
40         int                     byte_cnt;
41         int                     n;
42         int                     error = 0;
43         int                     fsblocks = 0;
44         int                     offset;
45
46         ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
47
48         fsblocks = xfs_symlink_blocks(mp, pathlen);
49         error = xfs_bmapi_read(ip, 0, fsblocks, mval, &nmaps, 0);
50         if (error)
51                 goto out;
52
53         offset = 0;
54         for (n = 0; n < nmaps; n++) {
55                 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
56                 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
57
58                 error = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0,
59                                 &bp, &xfs_symlink_buf_ops);
60                 if (error)
61                         return error;
62                 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
63                 if (pathlen < byte_cnt)
64                         byte_cnt = pathlen;
65
66                 cur_chunk = bp->b_addr;
67                 if (xfs_has_crc(mp)) {
68                         if (!xfs_symlink_hdr_ok(ip->i_ino, offset,
69                                                         byte_cnt, bp)) {
70                                 error = -EFSCORRUPTED;
71                                 xfs_alert(mp,
72 "symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)",
73                                         offset, byte_cnt, ip->i_ino);
74                                 xfs_buf_relse(bp);
75                                 goto out;
76
77                         }
78
79                         cur_chunk += sizeof(struct xfs_dsymlink_hdr);
80                 }
81
82                 memcpy(link + offset, cur_chunk, byte_cnt);
83
84                 pathlen -= byte_cnt;
85                 offset += byte_cnt;
86
87                 xfs_buf_relse(bp);
88         }
89         ASSERT(pathlen == 0);
90
91         link[ip->i_disk_size] = '\0';
92         error = 0;
93
94  out:
95         return error;
96 }
97
98 int
99 xfs_readlink(
100         struct xfs_inode        *ip,
101         char                    *link)
102 {
103         struct xfs_mount        *mp = ip->i_mount;
104         xfs_fsize_t             pathlen;
105         int                     error = -EFSCORRUPTED;
106
107         trace_xfs_readlink(ip);
108
109         if (xfs_is_shutdown(mp))
110                 return -EIO;
111
112         xfs_ilock(ip, XFS_ILOCK_SHARED);
113
114         pathlen = ip->i_disk_size;
115         if (!pathlen)
116                 goto out;
117
118         if (pathlen < 0 || pathlen > XFS_SYMLINK_MAXLEN) {
119                 xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
120                          __func__, (unsigned long long) ip->i_ino,
121                          (long long) pathlen);
122                 ASSERT(0);
123                 goto out;
124         }
125
126         if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
127                 /*
128                  * The VFS crashes on a NULL pointer, so return -EFSCORRUPTED
129                  * if if_data is junk.
130                  */
131                 if (XFS_IS_CORRUPT(ip->i_mount, !ip->i_df.if_u1.if_data))
132                         goto out;
133
134                 memcpy(link, ip->i_df.if_u1.if_data, pathlen + 1);
135                 error = 0;
136         } else {
137                 error = xfs_readlink_bmap_ilocked(ip, link);
138         }
139
140  out:
141         xfs_iunlock(ip, XFS_ILOCK_SHARED);
142         return error;
143 }
144
145 int
146 xfs_symlink(
147         struct user_namespace   *mnt_userns,
148         struct xfs_inode        *dp,
149         struct xfs_name         *link_name,
150         const char              *target_path,
151         umode_t                 mode,
152         struct xfs_inode        **ipp)
153 {
154         struct xfs_mount        *mp = dp->i_mount;
155         struct xfs_trans        *tp = NULL;
156         struct xfs_inode        *ip = NULL;
157         int                     error = 0;
158         int                     pathlen;
159         bool                    unlock_dp_on_error = false;
160         xfs_fileoff_t           first_fsb;
161         xfs_filblks_t           fs_blocks;
162         int                     nmaps;
163         struct xfs_bmbt_irec    mval[XFS_SYMLINK_MAPS];
164         xfs_daddr_t             d;
165         const char              *cur_chunk;
166         int                     byte_cnt;
167         int                     n;
168         struct xfs_buf          *bp;
169         prid_t                  prid;
170         struct xfs_dquot        *udqp = NULL;
171         struct xfs_dquot        *gdqp = NULL;
172         struct xfs_dquot        *pdqp = NULL;
173         uint                    resblks;
174         xfs_ino_t               ino;
175
176         *ipp = NULL;
177
178         trace_xfs_symlink(dp, link_name);
179
180         if (xfs_is_shutdown(mp))
181                 return -EIO;
182
183         /*
184          * Check component lengths of the target path name.
185          */
186         pathlen = strlen(target_path);
187         if (pathlen >= XFS_SYMLINK_MAXLEN)      /* total string too long */
188                 return -ENAMETOOLONG;
189         ASSERT(pathlen > 0);
190
191         prid = xfs_get_initial_prid(dp);
192
193         /*
194          * Make sure that we have allocated dquot(s) on disk.
195          */
196         error = xfs_qm_vop_dqalloc(dp, mapped_fsuid(mnt_userns, &init_user_ns),
197                         mapped_fsgid(mnt_userns, &init_user_ns), prid,
198                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
199                         &udqp, &gdqp, &pdqp);
200         if (error)
201                 return error;
202
203         /*
204          * The symlink will fit into the inode data fork?
205          * There can't be any attributes so we get the whole variable part.
206          */
207         if (pathlen <= XFS_LITINO(mp))
208                 fs_blocks = 0;
209         else
210                 fs_blocks = xfs_symlink_blocks(mp, pathlen);
211         resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
212
213         error = xfs_trans_alloc_icreate(mp, &M_RES(mp)->tr_symlink, udqp, gdqp,
214                         pdqp, resblks, &tp);
215         if (error)
216                 goto out_release_dquots;
217
218         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
219         unlock_dp_on_error = true;
220
221         /*
222          * Check whether the directory allows new symlinks or not.
223          */
224         if (dp->i_diflags & XFS_DIFLAG_NOSYMLINKS) {
225                 error = -EPERM;
226                 goto out_trans_cancel;
227         }
228
229         /*
230          * Allocate an inode for the symlink.
231          */
232         error = xfs_dialloc(&tp, dp->i_ino, S_IFLNK, &ino);
233         if (!error)
234                 error = xfs_init_new_inode(mnt_userns, tp, dp, ino,
235                                 S_IFLNK | (mode & ~S_IFMT), 1, 0, prid,
236                                 false, &ip);
237         if (error)
238                 goto out_trans_cancel;
239
240         /*
241          * Now we join the directory inode to the transaction.  We do not do it
242          * earlier because xfs_dir_ialloc might commit the previous transaction
243          * (and release all the locks).  An error from here on will result in
244          * the transaction cancel unlocking dp so don't do it explicitly in the
245          * error path.
246          */
247         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
248         unlock_dp_on_error = false;
249
250         /*
251          * Also attach the dquot(s) to it, if applicable.
252          */
253         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
254
255         resblks -= XFS_IALLOC_SPACE_RES(mp);
256         /*
257          * If the symlink will fit into the inode, write it inline.
258          */
259         if (pathlen <= XFS_IFORK_DSIZE(ip)) {
260                 xfs_init_local_fork(ip, XFS_DATA_FORK, target_path, pathlen);
261
262                 ip->i_disk_size = pathlen;
263                 ip->i_df.if_format = XFS_DINODE_FMT_LOCAL;
264                 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
265         } else {
266                 int     offset;
267
268                 first_fsb = 0;
269                 nmaps = XFS_SYMLINK_MAPS;
270
271                 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
272                                   XFS_BMAPI_METADATA, resblks, mval, &nmaps);
273                 if (error)
274                         goto out_trans_cancel;
275
276                 resblks -= fs_blocks;
277                 ip->i_disk_size = pathlen;
278                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
279
280                 cur_chunk = target_path;
281                 offset = 0;
282                 for (n = 0; n < nmaps; n++) {
283                         char    *buf;
284
285                         d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
286                         byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
287                         error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
288                                                BTOBB(byte_cnt), 0, &bp);
289                         if (error)
290                                 goto out_trans_cancel;
291                         bp->b_ops = &xfs_symlink_buf_ops;
292
293                         byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
294                         byte_cnt = min(byte_cnt, pathlen);
295
296                         buf = bp->b_addr;
297                         buf += xfs_symlink_hdr_set(mp, ip->i_ino, offset,
298                                                    byte_cnt, bp);
299
300                         memcpy(buf, cur_chunk, byte_cnt);
301
302                         cur_chunk += byte_cnt;
303                         pathlen -= byte_cnt;
304                         offset += byte_cnt;
305
306                         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);
307                         xfs_trans_log_buf(tp, bp, 0, (buf + byte_cnt - 1) -
308                                                         (char *)bp->b_addr);
309                 }
310                 ASSERT(pathlen == 0);
311         }
312         i_size_write(VFS_I(ip), ip->i_disk_size);
313
314         /*
315          * Create the directory entry for the symlink.
316          */
317         error = xfs_dir_createname(tp, dp, link_name, ip->i_ino, resblks);
318         if (error)
319                 goto out_trans_cancel;
320         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
321         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
322
323         /*
324          * If this is a synchronous mount, make sure that the
325          * symlink transaction goes to disk before returning to
326          * the user.
327          */
328         if (xfs_has_wsync(mp) || xfs_has_dirsync(mp))
329                 xfs_trans_set_sync(tp);
330
331         error = xfs_trans_commit(tp);
332         if (error)
333                 goto out_release_inode;
334
335         xfs_qm_dqrele(udqp);
336         xfs_qm_dqrele(gdqp);
337         xfs_qm_dqrele(pdqp);
338
339         *ipp = ip;
340         return 0;
341
342 out_trans_cancel:
343         xfs_trans_cancel(tp);
344 out_release_inode:
345         /*
346          * Wait until after the current transaction is aborted to finish the
347          * setup of the inode and release the inode.  This prevents recursive
348          * transactions and deadlocks from xfs_inactive.
349          */
350         if (ip) {
351                 xfs_finish_inode_setup(ip);
352                 xfs_irele(ip);
353         }
354 out_release_dquots:
355         xfs_qm_dqrele(udqp);
356         xfs_qm_dqrele(gdqp);
357         xfs_qm_dqrele(pdqp);
358
359         if (unlock_dp_on_error)
360                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
361         return error;
362 }
363
364 /*
365  * Free a symlink that has blocks associated with it.
366  *
367  * Note: zero length symlinks are not allowed to exist. When we set the size to
368  * zero, also change it to a regular file so that it does not get written to
369  * disk as a zero length symlink. The inode is on the unlinked list already, so
370  * userspace cannot find this inode anymore, so this change is not user visible
371  * but allows us to catch corrupt zero-length symlinks in the verifiers.
372  */
373 STATIC int
374 xfs_inactive_symlink_rmt(
375         struct xfs_inode *ip)
376 {
377         struct xfs_buf  *bp;
378         int             done;
379         int             error;
380         int             i;
381         xfs_mount_t     *mp;
382         xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS];
383         int             nmaps;
384         int             size;
385         xfs_trans_t     *tp;
386
387         mp = ip->i_mount;
388         ASSERT(!xfs_need_iread_extents(&ip->i_df));
389         /*
390          * We're freeing a symlink that has some
391          * blocks allocated to it.  Free the
392          * blocks here.  We know that we've got
393          * either 1 or 2 extents and that we can
394          * free them all in one bunmapi call.
395          */
396         ASSERT(ip->i_df.if_nextents > 0 && ip->i_df.if_nextents <= 2);
397
398         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
399         if (error)
400                 return error;
401
402         xfs_ilock(ip, XFS_ILOCK_EXCL);
403         xfs_trans_ijoin(tp, ip, 0);
404
405         /*
406          * Lock the inode, fix the size, turn it into a regular file and join it
407          * to the transaction.  Hold it so in the normal path, we still have it
408          * locked for the second transaction.  In the error paths we need it
409          * held so the cancel won't rele it, see below.
410          */
411         size = (int)ip->i_disk_size;
412         ip->i_disk_size = 0;
413         VFS_I(ip)->i_mode = (VFS_I(ip)->i_mode & ~S_IFMT) | S_IFREG;
414         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
415         /*
416          * Find the block(s) so we can inval and unmap them.
417          */
418         done = 0;
419         nmaps = ARRAY_SIZE(mval);
420         error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size),
421                                 mval, &nmaps, 0);
422         if (error)
423                 goto error_trans_cancel;
424         /*
425          * Invalidate the block(s). No validation is done.
426          */
427         for (i = 0; i < nmaps; i++) {
428                 error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
429                                 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
430                                 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0,
431                                 &bp);
432                 if (error)
433                         goto error_trans_cancel;
434                 xfs_trans_binval(tp, bp);
435         }
436         /*
437          * Unmap the dead block(s) to the dfops.
438          */
439         error = xfs_bunmapi(tp, ip, 0, size, 0, nmaps, &done);
440         if (error)
441                 goto error_trans_cancel;
442         ASSERT(done);
443
444         /*
445          * Commit the transaction. This first logs the EFI and the inode, then
446          * rolls and commits the transaction that frees the extents.
447          */
448         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
449         error = xfs_trans_commit(tp);
450         if (error) {
451                 ASSERT(xfs_is_shutdown(mp));
452                 goto error_unlock;
453         }
454
455         /*
456          * Remove the memory for extent descriptions (just bookkeeping).
457          */
458         if (ip->i_df.if_bytes)
459                 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
460         ASSERT(ip->i_df.if_bytes == 0);
461
462         xfs_iunlock(ip, XFS_ILOCK_EXCL);
463         return 0;
464
465 error_trans_cancel:
466         xfs_trans_cancel(tp);
467 error_unlock:
468         xfs_iunlock(ip, XFS_ILOCK_EXCL);
469         return error;
470 }
471
472 /*
473  * xfs_inactive_symlink - free a symlink
474  */
475 int
476 xfs_inactive_symlink(
477         struct xfs_inode        *ip)
478 {
479         struct xfs_mount        *mp = ip->i_mount;
480         int                     pathlen;
481
482         trace_xfs_inactive_symlink(ip);
483
484         if (xfs_is_shutdown(mp))
485                 return -EIO;
486
487         xfs_ilock(ip, XFS_ILOCK_EXCL);
488         pathlen = (int)ip->i_disk_size;
489         ASSERT(pathlen);
490
491         if (pathlen <= 0 || pathlen > XFS_SYMLINK_MAXLEN) {
492                 xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)",
493                          __func__, (unsigned long long)ip->i_ino, pathlen);
494                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
495                 ASSERT(0);
496                 return -EFSCORRUPTED;
497         }
498
499         /*
500          * Inline fork state gets removed by xfs_difree() so we have nothing to
501          * do here in that case.
502          */
503         if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
504                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
505                 return 0;
506         }
507
508         xfs_iunlock(ip, XFS_ILOCK_EXCL);
509
510         /* remove the remote symlink */
511         return xfs_inactive_symlink_rmt(ip);
512 }