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