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 #include "xfs_health.h"
  27 #include "xfs_symlink_remote.h"
  28
  29 int
  30 xfs_readlink(
  31         struct xfs_inode        *ip,
  32         char                    *link)
  33 {
  34         struct xfs_mount        *mp = ip->i_mount;
  35         xfs_fsize_t             pathlen;
  36         int                     error;
  37
  38         trace_xfs_readlink(ip);
  39
  40         if (xfs_is_shutdown(mp))
  41                 return -EIO;
  42         if (xfs_ifork_zapped(ip, XFS_DATA_FORK))
  43                 return -EIO;
  44
  45         xfs_ilock(ip, XFS_ILOCK_SHARED);
  46
  47         pathlen = ip->i_disk_size;
  48         if (!pathlen)
  49                 goto out_corrupt;
  50
  51         if (pathlen < 0 || pathlen > XFS_SYMLINK_MAXLEN) {
  52                 xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
  53                          __func__, (unsigned long long) ip->i_ino,
  54                          (long long) pathlen);
  55                 ASSERT(0);
  56                 goto out_corrupt;
  57         }
  58
  59         if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
  60                 /*
  61                  * The VFS crashes on a NULL pointer, so return -EFSCORRUPTED
  62                  * if if_data is junk.
  63                  */
  64                 if (XFS_IS_CORRUPT(ip->i_mount, !ip->i_df.if_data))
  65                         goto out_corrupt;
  66
  67                 memcpy(link, ip->i_df.if_data, pathlen + 1);
  68                 error = 0;
  69         } else {
  70                 error = xfs_symlink_remote_read(ip, link);
  71         }
  72
  73         xfs_iunlock(ip, XFS_ILOCK_SHARED);
  74         return error;
  75  out_corrupt:
  76         xfs_iunlock(ip, XFS_ILOCK_SHARED);
  77         xfs_inode_mark_sick(ip, XFS_SICK_INO_SYMLINK);
  78         return -EFSCORRUPTED;
  79 }
  80
  81 int
  82 xfs_symlink(
  83         struct mnt_idmap        *idmap,
  84         struct xfs_inode        *dp,
  85         struct xfs_name         *link_name,
  86         const char              *target_path,
  87         umode_t                 mode,
  88         struct xfs_inode        **ipp)
  89 {
  90         struct xfs_mount        *mp = dp->i_mount;
  91         struct xfs_trans        *tp = NULL;
  92         struct xfs_inode        *ip = NULL;
  93         int                     error = 0;
  94         int                     pathlen;
  95         bool                    unlock_dp_on_error = false;
  96         xfs_filblks_t           fs_blocks;
  97         prid_t                  prid;
  98         struct xfs_dquot        *udqp = NULL;
  99         struct xfs_dquot        *gdqp = NULL;
 100         struct xfs_dquot        *pdqp = NULL;
 101         uint                    resblks;
 102         xfs_ino_t               ino;
 103
 104         *ipp = NULL;
 105
 106         trace_xfs_symlink(dp, link_name);
 107
 108         if (xfs_is_shutdown(mp))
 109                 return -EIO;
 110
 111         /*
 112          * Check component lengths of the target path name.
 113          */
 114         pathlen = strlen(target_path);
 115         if (pathlen >= XFS_SYMLINK_MAXLEN)      /* total string too long */
 116                 return -ENAMETOOLONG;
 117         ASSERT(pathlen > 0);
 118
 119         prid = xfs_get_initial_prid(dp);
 120
 121         /*
 122          * Make sure that we have allocated dquot(s) on disk.
 123          */
 124         error = xfs_qm_vop_dqalloc(dp, mapped_fsuid(idmap, &init_user_ns),
 125                         mapped_fsgid(idmap, &init_user_ns), prid,
 126                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
 127                         &udqp, &gdqp, &pdqp);
 128         if (error)
 129                 return error;
 130
 131         /*
 132          * The symlink will fit into the inode data fork?
 133          * There can't be any attributes so we get the whole variable part.
 134          */
 135         if (pathlen <= XFS_LITINO(mp))
 136                 fs_blocks = 0;
 137         else
 138                 fs_blocks = xfs_symlink_blocks(mp, pathlen);
 139         resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
 140
 141         error = xfs_trans_alloc_icreate(mp, &M_RES(mp)->tr_symlink, udqp, gdqp,
 142                         pdqp, resblks, &tp);
 143         if (error)
 144                 goto out_release_dquots;
 145
 146         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
 147         unlock_dp_on_error = true;
 148
 149         /*
 150          * Check whether the directory allows new symlinks or not.
 151          */
 152         if (dp->i_diflags & XFS_DIFLAG_NOSYMLINKS) {
 153                 error = -EPERM;
 154                 goto out_trans_cancel;
 155         }
 156
 157         /*
 158          * Allocate an inode for the symlink.
 159          */
 160         error = xfs_dialloc(&tp, dp->i_ino, S_IFLNK, &ino);
 161         if (!error)
 162                 error = xfs_init_new_inode(idmap, tp, dp, ino,
 163                                 S_IFLNK | (mode & ~S_IFMT), 1, 0, prid,
 164                                 false, &ip);
 165         if (error)
 166                 goto out_trans_cancel;
 167
 168         /*
 169          * Now we join the directory inode to the transaction.  We do not do it
 170          * earlier because xfs_dir_ialloc might commit the previous transaction
 171          * (and release all the locks).  An error from here on will result in
 172          * the transaction cancel unlocking dp so don't do it explicitly in the
 173          * error path.
 174          */
 175         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
 176         unlock_dp_on_error = false;
 177
 178         /*
 179          * Also attach the dquot(s) to it, if applicable.
 180          */
 181         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
 182
 183         resblks -= XFS_IALLOC_SPACE_RES(mp);
 184         error = xfs_symlink_write_target(tp, ip, target_path, pathlen,
 185                         fs_blocks, resblks);
 186         if (error)
 187                 goto out_trans_cancel;
 188         resblks -= fs_blocks;
 189         i_size_write(VFS_I(ip), ip->i_disk_size);
 190
 191         /*
 192          * Create the directory entry for the symlink.
 193          */
 194         error = xfs_dir_createname(tp, dp, link_name, ip->i_ino, resblks);
 195         if (error)
 196                 goto out_trans_cancel;
 197         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 198         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 199         xfs_dir_update_hook(dp, ip, 1, link_name);
 200
 201         /*
 202          * If this is a synchronous mount, make sure that the
 203          * symlink transaction goes to disk before returning to
 204          * the user.
 205          */
 206         if (xfs_has_wsync(mp) || xfs_has_dirsync(mp))
 207                 xfs_trans_set_sync(tp);
 208
 209         error = xfs_trans_commit(tp);
 210         if (error)
 211                 goto out_release_inode;
 212
 213         xfs_qm_dqrele(udqp);
 214         xfs_qm_dqrele(gdqp);
 215         xfs_qm_dqrele(pdqp);
 216
 217         *ipp = ip;
 218         return 0;
 219
 220 out_trans_cancel:
 221         xfs_trans_cancel(tp);
 222 out_release_inode:
 223         /*
 224          * Wait until after the current transaction is aborted to finish the
 225          * setup of the inode and release the inode.  This prevents recursive
 226          * transactions and deadlocks from xfs_inactive.
 227          */
 228         if (ip) {
 229                 xfs_finish_inode_setup(ip);
 230                 xfs_irele(ip);
 231         }
 232 out_release_dquots:
 233         xfs_qm_dqrele(udqp);
 234         xfs_qm_dqrele(gdqp);
 235         xfs_qm_dqrele(pdqp);
 236
 237         if (unlock_dp_on_error)
 238                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
 239         return error;
 240 }
 241
 242 /*
 243  * Free a symlink that has blocks associated with it.
 244  *
 245  * Note: zero length symlinks are not allowed to exist. When we set the size to
 246  * zero, also change it to a regular file so that it does not get written to
 247  * disk as a zero length symlink. The inode is on the unlinked list already, so
 248  * userspace cannot find this inode anymore, so this change is not user visible
 249  * but allows us to catch corrupt zero-length symlinks in the verifiers.
 250  */
 251 STATIC int
 252 xfs_inactive_symlink_rmt(
 253         struct xfs_inode *ip)
 254 {
 255         struct xfs_buf  *bp;
 256         int             done;
 257         int             error;
 258         int             i;
 259         xfs_mount_t     *mp;
 260         xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS];
 261         int             nmaps;
 262         int             size;
 263         xfs_trans_t     *tp;
 264
 265         mp = ip->i_mount;
 266         ASSERT(!xfs_need_iread_extents(&ip->i_df));
 267         /*
 268          * We're freeing a symlink that has some
 269          * blocks allocated to it.  Free the
 270          * blocks here.  We know that we've got
 271          * either 1 or 2 extents and that we can
 272          * free them all in one bunmapi call.
 273          */
 274         ASSERT(ip->i_df.if_nextents > 0 && ip->i_df.if_nextents <= 2);
 275
 276         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
 277         if (error)
 278                 return error;
 279
 280         xfs_ilock(ip, XFS_ILOCK_EXCL);
 281         xfs_trans_ijoin(tp, ip, 0);
 282
 283         /*
 284          * Lock the inode, fix the size, turn it into a regular file and join it
 285          * to the transaction.  Hold it so in the normal path, we still have it
 286          * locked for the second transaction.  In the error paths we need it
 287          * held so the cancel won't rele it, see below.
 288          */
 289         size = (int)ip->i_disk_size;
 290         ip->i_disk_size = 0;
 291         VFS_I(ip)->i_mode = (VFS_I(ip)->i_mode & ~S_IFMT) | S_IFREG;
 292         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 293         /*
 294          * Find the block(s) so we can inval and unmap them.
 295          */
 296         done = 0;
 297         nmaps = ARRAY_SIZE(mval);
 298         error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size),
 299                                 mval, &nmaps, 0);
 300         if (error)
 301                 goto error_trans_cancel;
 302         /*
 303          * Invalidate the block(s). No validation is done.
 304          */
 305         for (i = 0; i < nmaps; i++) {
 306                 error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
 307                                 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
 308                                 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0,
 309                                 &bp);
 310                 if (error)
 311                         goto error_trans_cancel;
 312                 xfs_trans_binval(tp, bp);
 313         }
 314         /*
 315          * Unmap the dead block(s) to the dfops.
 316          */
 317         error = xfs_bunmapi(tp, ip, 0, size, 0, nmaps, &done);
 318         if (error)
 319                 goto error_trans_cancel;
 320         ASSERT(done);
 321
 322         /*
 323          * Commit the transaction. This first logs the EFI and the inode, then
 324          * rolls and commits the transaction that frees the extents.
 325          */
 326         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 327         error = xfs_trans_commit(tp);
 328         if (error) {
 329                 ASSERT(xfs_is_shutdown(mp));
 330                 goto error_unlock;
 331         }
 332
 333         /*
 334          * Remove the memory for extent descriptions (just bookkeeping).
 335          */
 336         if (ip->i_df.if_bytes)
 337                 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
 338         ASSERT(ip->i_df.if_bytes == 0);
 339
 340         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 341         return 0;
 342
 343 error_trans_cancel:
 344         xfs_trans_cancel(tp);
 345 error_unlock:
 346         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 347         return error;
 348 }
 349
 350 /*
 351  * xfs_inactive_symlink - free a symlink
 352  */
 353 int
 354 xfs_inactive_symlink(
 355         struct xfs_inode        *ip)
 356 {
 357         struct xfs_mount        *mp = ip->i_mount;
 358         int                     pathlen;
 359
 360         trace_xfs_inactive_symlink(ip);
 361
 362         if (xfs_is_shutdown(mp))
 363                 return -EIO;
 364
 365         xfs_ilock(ip, XFS_ILOCK_EXCL);
 366         pathlen = (int)ip->i_disk_size;
 367         ASSERT(pathlen);
 368
 369         if (pathlen <= 0 || pathlen > XFS_SYMLINK_MAXLEN) {
 370                 xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)",
 371                          __func__, (unsigned long long)ip->i_ino, pathlen);
 372                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
 373                 ASSERT(0);
 374                 xfs_inode_mark_sick(ip, XFS_SICK_INO_SYMLINK);
 375                 return -EFSCORRUPTED;
 376         }
 377
 378         /*
 379          * Inline fork state gets removed by xfs_difree() so we have nothing to
 380          * do here in that case.
 381          */
 382         if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
 383                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
 384                 return 0;
 385         }
 386
 387         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 388
 389         /* remove the remote symlink */
 390         return xfs_inactive_symlink_rmt(ip);
 391 }