2013-04-02 23:11:18 -06:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2000-2006 Silicon Graphics, Inc.
|
|
|
|
* Copyright (c) 2012-2013 Red Hat, Inc.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_shared.h"
|
2013-04-02 23:11:18 -06:00
|
|
|
#include "xfs_fs.h"
|
2013-08-12 04:49:26 -06:00
|
|
|
#include "xfs_format.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2013-04-02 23:11:18 -06:00
|
|
|
#include "xfs_bit.h"
|
|
|
|
#include "xfs_mount.h"
|
2013-10-14 16:17:51 -06:00
|
|
|
#include "xfs_da_format.h"
|
2014-06-05 23:14:11 -06:00
|
|
|
#include "xfs_da_btree.h"
|
2016-08-02 19:15:38 -06:00
|
|
|
#include "xfs_defer.h"
|
2013-08-12 04:49:37 -06:00
|
|
|
#include "xfs_dir2.h"
|
2013-04-02 23:11:18 -06:00
|
|
|
#include "xfs_inode.h"
|
|
|
|
#include "xfs_ialloc.h"
|
|
|
|
#include "xfs_alloc.h"
|
|
|
|
#include "xfs_bmap.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_bmap_btree.h"
|
2013-08-12 04:49:42 -06:00
|
|
|
#include "xfs_bmap_util.h"
|
2013-04-02 23:11:18 -06:00
|
|
|
#include "xfs_error.h"
|
|
|
|
#include "xfs_quota.h"
|
|
|
|
#include "xfs_trans_space.h"
|
|
|
|
#include "xfs_trace.h"
|
|
|
|
#include "xfs_symlink.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_log.h"
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
/* ----- Kernel only functions below ----- */
|
|
|
|
STATIC int
|
|
|
|
xfs_readlink_bmap(
|
2013-04-02 23:11:19 -06:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
char *link)
|
2013-04-02 23:11:18 -06:00
|
|
|
{
|
2013-04-02 23:11:19 -06:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS];
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
xfs_daddr_t d;
|
|
|
|
char *cur_chunk;
|
|
|
|
int pathlen = ip->i_d.di_size;
|
|
|
|
int nmaps = XFS_SYMLINK_MAPS;
|
|
|
|
int byte_cnt;
|
|
|
|
int n;
|
|
|
|
int error = 0;
|
|
|
|
int fsblocks = 0;
|
|
|
|
int offset;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
2013-04-02 23:11:19 -06:00
|
|
|
fsblocks = xfs_symlink_blocks(mp, pathlen);
|
|
|
|
error = xfs_bmapi_read(ip, 0, fsblocks, mval, &nmaps, 0);
|
2013-04-02 23:11:18 -06:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2013-04-02 23:11:19 -06:00
|
|
|
offset = 0;
|
2013-04-02 23:11:18 -06:00
|
|
|
for (n = 0; n < nmaps; n++) {
|
|
|
|
d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
|
|
|
|
byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
|
|
|
|
|
2013-04-02 23:11:19 -06:00
|
|
|
bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0,
|
|
|
|
&xfs_symlink_buf_ops);
|
2013-04-02 23:11:18 -06:00
|
|
|
if (!bp)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2013-04-02 23:11:18 -06:00
|
|
|
error = bp->b_error;
|
|
|
|
if (error) {
|
|
|
|
xfs_buf_ioerror_alert(bp, __func__);
|
|
|
|
xfs_buf_relse(bp);
|
2014-03-06 22:19:14 -07:00
|
|
|
|
|
|
|
/* bad CRC means corrupted metadata */
|
2014-06-24 22:58:08 -06:00
|
|
|
if (error == -EFSBADCRC)
|
|
|
|
error = -EFSCORRUPTED;
|
2013-04-02 23:11:18 -06:00
|
|
|
goto out;
|
|
|
|
}
|
2013-04-02 23:11:19 -06:00
|
|
|
byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
|
2013-04-02 23:11:18 -06:00
|
|
|
if (pathlen < byte_cnt)
|
|
|
|
byte_cnt = pathlen;
|
2013-04-02 23:11:19 -06:00
|
|
|
|
|
|
|
cur_chunk = bp->b_addr;
|
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb)) {
|
2014-04-14 03:05:43 -06:00
|
|
|
if (!xfs_symlink_hdr_ok(ip->i_ino, offset,
|
2013-04-02 23:11:19 -06:00
|
|
|
byte_cnt, bp)) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
2013-04-02 23:11:19 -06:00
|
|
|
xfs_alert(mp,
|
|
|
|
"symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)",
|
|
|
|
offset, byte_cnt, ip->i_ino);
|
|
|
|
xfs_buf_relse(bp);
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
cur_chunk += sizeof(struct xfs_dsymlink_hdr);
|
|
|
|
}
|
|
|
|
|
2015-06-21 17:42:48 -06:00
|
|
|
memcpy(link + offset, cur_chunk, byte_cnt);
|
2013-04-02 23:11:19 -06:00
|
|
|
|
2013-04-02 23:11:18 -06:00
|
|
|
pathlen -= byte_cnt;
|
2013-04-02 23:11:19 -06:00
|
|
|
offset += byte_cnt;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
xfs_buf_relse(bp);
|
|
|
|
}
|
2013-04-02 23:11:19 -06:00
|
|
|
ASSERT(pathlen == 0);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
link[ip->i_d.di_size] = '\0';
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_readlink(
|
2013-04-02 23:11:19 -06:00
|
|
|
struct xfs_inode *ip,
|
2013-04-02 23:11:18 -06:00
|
|
|
char *link)
|
|
|
|
{
|
2013-04-02 23:11:19 -06:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2013-04-02 23:11:18 -06:00
|
|
|
xfs_fsize_t pathlen;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
trace_xfs_readlink(ip);
|
|
|
|
|
2016-04-05 15:53:29 -06:00
|
|
|
ASSERT(!(ip->i_df.if_flags & XFS_IFINLINE));
|
|
|
|
|
2013-04-02 23:11:18 -06:00
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_SHARED);
|
|
|
|
|
|
|
|
pathlen = ip->i_d.di_size;
|
|
|
|
if (!pathlen)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (pathlen < 0 || pathlen > MAXPATHLEN) {
|
|
|
|
xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
|
|
|
|
__func__, (unsigned long long) ip->i_ino,
|
|
|
|
(long long) pathlen);
|
|
|
|
ASSERT(0);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
2013-04-02 23:11:18 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-04-05 15:53:29 -06:00
|
|
|
error = xfs_readlink_bmap(ip, link);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_symlink(
|
2013-04-02 23:11:19 -06:00
|
|
|
struct xfs_inode *dp,
|
2013-04-02 23:11:18 -06:00
|
|
|
struct xfs_name *link_name,
|
|
|
|
const char *target_path,
|
|
|
|
umode_t mode,
|
2013-04-02 23:11:19 -06:00
|
|
|
struct xfs_inode **ipp)
|
2013-04-02 23:11:18 -06:00
|
|
|
{
|
2013-04-02 23:11:19 -06:00
|
|
|
struct xfs_mount *mp = dp->i_mount;
|
|
|
|
struct xfs_trans *tp = NULL;
|
|
|
|
struct xfs_inode *ip = NULL;
|
|
|
|
int error = 0;
|
2013-04-02 23:11:18 -06:00
|
|
|
int pathlen;
|
2016-08-02 19:19:29 -06:00
|
|
|
struct xfs_defer_ops dfops;
|
2013-04-02 23:11:18 -06:00
|
|
|
xfs_fsblock_t first_block;
|
2015-02-23 04:38:08 -07:00
|
|
|
bool unlock_dp_on_error = false;
|
2013-04-02 23:11:18 -06:00
|
|
|
xfs_fileoff_t first_fsb;
|
|
|
|
xfs_filblks_t fs_blocks;
|
|
|
|
int nmaps;
|
2013-04-02 23:11:19 -06:00
|
|
|
struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS];
|
2013-04-02 23:11:18 -06:00
|
|
|
xfs_daddr_t d;
|
|
|
|
const char *cur_chunk;
|
|
|
|
int byte_cnt;
|
|
|
|
int n;
|
|
|
|
xfs_buf_t *bp;
|
|
|
|
prid_t prid;
|
2013-06-27 16:25:07 -06:00
|
|
|
struct xfs_dquot *udqp = NULL;
|
|
|
|
struct xfs_dquot *gdqp = NULL;
|
2013-07-10 23:00:40 -06:00
|
|
|
struct xfs_dquot *pdqp = NULL;
|
2013-04-02 23:11:18 -06:00
|
|
|
uint resblks;
|
|
|
|
|
|
|
|
*ipp = NULL;
|
|
|
|
|
|
|
|
trace_xfs_symlink(dp, link_name);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check component lengths of the target path name.
|
|
|
|
*/
|
|
|
|
pathlen = strlen(target_path);
|
|
|
|
if (pathlen >= MAXPATHLEN) /* total string too long */
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENAMETOOLONG;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
udqp = gdqp = NULL;
|
2013-12-17 17:22:39 -07:00
|
|
|
prid = xfs_get_initial_prid(dp);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that we have allocated dquot(s) on disk.
|
|
|
|
*/
|
2013-08-15 12:08:01 -06:00
|
|
|
error = xfs_qm_vop_dqalloc(dp,
|
|
|
|
xfs_kuid_to_uid(current_fsuid()),
|
|
|
|
xfs_kgid_to_gid(current_fsgid()), prid,
|
|
|
|
XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
|
|
|
|
&udqp, &gdqp, &pdqp);
|
2013-04-02 23:11:18 -06:00
|
|
|
if (error)
|
2015-02-23 04:38:08 -07:00
|
|
|
return error;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The symlink will fit into the inode data fork?
|
|
|
|
* There can't be any attributes so we get the whole variable part.
|
|
|
|
*/
|
|
|
|
if (pathlen <= XFS_LITINO(mp, dp->i_d.di_version))
|
|
|
|
fs_blocks = 0;
|
|
|
|
else
|
2013-05-27 00:38:20 -06:00
|
|
|
fs_blocks = xfs_symlink_blocks(mp, pathlen);
|
2013-04-02 23:11:18 -06:00
|
|
|
resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
|
2016-04-05 17:19:55 -06:00
|
|
|
|
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_symlink, resblks, 0, 0, &tp);
|
2014-06-24 22:58:08 -06:00
|
|
|
if (error == -ENOSPC && fs_blocks == 0) {
|
2013-04-02 23:11:18 -06:00
|
|
|
resblks = 0;
|
2016-04-05 17:19:55 -06:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_symlink, 0, 0, 0,
|
|
|
|
&tp);
|
2013-04-02 23:11:18 -06:00
|
|
|
}
|
2015-06-03 21:47:56 -06:00
|
|
|
if (error)
|
2016-04-05 17:19:55 -06:00
|
|
|
goto out_release_inode;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
xfs: stop holding ILOCK over filldir callbacks
The recent change to the readdir locking made in 40194ec ("xfs:
reinstate the ilock in xfs_readdir") for CXFS directory sanity was
probably the wrong thing to do. Deep in the readdir code we
can take page faults in the filldir callback, and so taking a page
fault while holding an inode ilock creates a new set of locking
issues that lockdep warns all over the place about.
The locking order for regular inodes w.r.t. page faults is io_lock
-> pagefault -> mmap_sem -> ilock. The directory readdir code now
triggers ilock -> page fault -> mmap_sem. While we cannot deadlock
at this point, it inverts all the locking patterns that lockdep
normally sees on XFS inodes, and so triggers lockdep. We worked
around this with commit 93a8614 ("xfs: fix directory inode iolock
lockdep false positive"), but that then just moved the lockdep
warning to deeper in the page fault path and triggered on security
inode locks. Fixing the shmem issue there just moved the lockdep
reports somewhere else, and now we are getting false positives from
filesystem freezing annotations getting confused.
Further, if we enter memory reclaim in a readdir path, we now get
lockdep warning about potential deadlocks because the ilock is held
when we enter reclaim. This, again, is different to a regular file
in that we never allow memory reclaim to run while holding the ilock
for regular files. Hence lockdep now throws
ilock->kmalloc->reclaim->ilock warnings.
Basically, the problem is that the ilock is being used to protect
the directory data and the inode metadata, whereas for a regular
file the iolock protects the data and the ilock protects the
metadata. From the VFS perspective, the i_mutex serialises all
accesses to the directory data, and so not holding the ilock for
readdir doesn't matter. The issue is that CXFS doesn't access
directory data via the VFS, so it has no "data serialisaton"
mechanism. Hence we need to hold the IOLOCK in the correct places to
provide this low level directory data access serialisation.
The ilock can then be used just when the extent list needs to be
read, just like we do for regular files. The directory modification
code can take the iolock exclusive when the ilock is also taken,
and this then ensures that readdir is correct excluded while
modifications are in progress.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-18 18:33:00 -06:00
|
|
|
xfs_ilock(dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL |
|
|
|
|
XFS_IOLOCK_PARENT | XFS_ILOCK_PARENT);
|
2013-04-02 23:11:18 -06:00
|
|
|
unlock_dp_on_error = true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether the directory allows new symlinks or not.
|
|
|
|
*/
|
|
|
|
if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EPERM;
|
2015-02-23 04:38:08 -07:00
|
|
|
goto out_trans_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reserve disk quota : blocks and inode.
|
|
|
|
*/
|
2013-07-10 23:00:40 -06:00
|
|
|
error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
|
|
|
|
pdqp, resblks, 1, 0);
|
2013-04-02 23:11:18 -06:00
|
|
|
if (error)
|
2015-02-23 04:38:08 -07:00
|
|
|
goto out_trans_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for ability to enter directory entry, if no space reserved.
|
|
|
|
*/
|
2014-09-08 19:57:52 -06:00
|
|
|
if (!resblks) {
|
|
|
|
error = xfs_dir_canenter(tp, dp, link_name);
|
|
|
|
if (error)
|
2015-02-23 04:38:08 -07:00
|
|
|
goto out_trans_cancel;
|
2014-09-08 19:57:52 -06:00
|
|
|
}
|
2013-04-02 23:11:18 -06:00
|
|
|
/*
|
|
|
|
* Initialize the bmap freelist prior to calling either
|
|
|
|
* bmapi or the directory create code.
|
|
|
|
*/
|
2016-08-02 19:19:29 -06:00
|
|
|
xfs_defer_init(&dfops, &first_block);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate an inode for the symlink.
|
|
|
|
*/
|
|
|
|
error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
|
|
|
|
prid, resblks > 0, &ip, NULL);
|
2015-02-23 04:38:08 -07:00
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
/*
|
2015-02-23 04:38:08 -07:00
|
|
|
* Now we join the directory inode to the transaction. We do not do it
|
|
|
|
* earlier because xfs_dir_ialloc might commit the previous transaction
|
|
|
|
* (and release all the locks). An error from here on will result in
|
|
|
|
* the transaction cancel unlocking dp so don't do it explicitly in the
|
2013-04-02 23:11:18 -06:00
|
|
|
* error path.
|
|
|
|
*/
|
xfs: stop holding ILOCK over filldir callbacks
The recent change to the readdir locking made in 40194ec ("xfs:
reinstate the ilock in xfs_readdir") for CXFS directory sanity was
probably the wrong thing to do. Deep in the readdir code we
can take page faults in the filldir callback, and so taking a page
fault while holding an inode ilock creates a new set of locking
issues that lockdep warns all over the place about.
The locking order for regular inodes w.r.t. page faults is io_lock
-> pagefault -> mmap_sem -> ilock. The directory readdir code now
triggers ilock -> page fault -> mmap_sem. While we cannot deadlock
at this point, it inverts all the locking patterns that lockdep
normally sees on XFS inodes, and so triggers lockdep. We worked
around this with commit 93a8614 ("xfs: fix directory inode iolock
lockdep false positive"), but that then just moved the lockdep
warning to deeper in the page fault path and triggered on security
inode locks. Fixing the shmem issue there just moved the lockdep
reports somewhere else, and now we are getting false positives from
filesystem freezing annotations getting confused.
Further, if we enter memory reclaim in a readdir path, we now get
lockdep warning about potential deadlocks because the ilock is held
when we enter reclaim. This, again, is different to a regular file
in that we never allow memory reclaim to run while holding the ilock
for regular files. Hence lockdep now throws
ilock->kmalloc->reclaim->ilock warnings.
Basically, the problem is that the ilock is being used to protect
the directory data and the inode metadata, whereas for a regular
file the iolock protects the data and the ilock protects the
metadata. From the VFS perspective, the i_mutex serialises all
accesses to the directory data, and so not holding the ilock for
readdir doesn't matter. The issue is that CXFS doesn't access
directory data via the VFS, so it has no "data serialisaton"
mechanism. Hence we need to hold the IOLOCK in the correct places to
provide this low level directory data access serialisation.
The ilock can then be used just when the extent list needs to be
read, just like we do for regular files. The directory modification
code can take the iolock exclusive when the ilock is also taken,
and this then ensures that readdir is correct excluded while
modifications are in progress.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-18 18:33:00 -06:00
|
|
|
xfs_trans_ijoin(tp, dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
|
2013-04-02 23:11:18 -06:00
|
|
|
unlock_dp_on_error = false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Also attach the dquot(s) to it, if applicable.
|
|
|
|
*/
|
2013-07-10 23:00:40 -06:00
|
|
|
xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
if (resblks)
|
|
|
|
resblks -= XFS_IALLOC_SPACE_RES(mp);
|
|
|
|
/*
|
|
|
|
* If the symlink will fit into the inode, write it inline.
|
|
|
|
*/
|
|
|
|
if (pathlen <= XFS_IFORK_DSIZE(ip)) {
|
2016-04-05 15:41:43 -06:00
|
|
|
xfs_init_local_fork(ip, XFS_DATA_FORK, target_path, pathlen);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
2016-04-05 15:41:43 -06:00
|
|
|
ip->i_d.di_size = pathlen;
|
2013-04-02 23:11:18 -06:00
|
|
|
ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
|
|
|
|
} else {
|
2013-04-02 23:11:19 -06:00
|
|
|
int offset;
|
|
|
|
|
2013-04-02 23:11:18 -06:00
|
|
|
first_fsb = 0;
|
|
|
|
nmaps = XFS_SYMLINK_MAPS;
|
|
|
|
|
|
|
|
error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
|
|
|
|
XFS_BMAPI_METADATA, &first_block, resblks,
|
2016-08-02 19:19:29 -06:00
|
|
|
mval, &nmaps, &dfops);
|
2013-04-02 23:11:18 -06:00
|
|
|
if (error)
|
2015-02-23 04:38:08 -07:00
|
|
|
goto out_bmap_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
if (resblks)
|
|
|
|
resblks -= fs_blocks;
|
|
|
|
ip->i_d.di_size = pathlen;
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
|
|
|
|
cur_chunk = target_path;
|
2013-04-02 23:11:19 -06:00
|
|
|
offset = 0;
|
2013-04-02 23:11:18 -06:00
|
|
|
for (n = 0; n < nmaps; n++) {
|
2013-05-27 00:38:20 -06:00
|
|
|
char *buf;
|
2013-04-02 23:11:19 -06:00
|
|
|
|
2013-04-02 23:11:18 -06:00
|
|
|
d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
|
|
|
|
byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
|
|
|
|
bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
|
|
|
|
BTOBB(byte_cnt), 0);
|
|
|
|
if (!bp) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENOMEM;
|
2015-02-23 04:38:08 -07:00
|
|
|
goto out_bmap_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
}
|
2013-04-02 23:11:19 -06:00
|
|
|
bp->b_ops = &xfs_symlink_buf_ops;
|
|
|
|
|
|
|
|
byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
|
2013-05-27 00:38:20 -06:00
|
|
|
byte_cnt = min(byte_cnt, pathlen);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
2013-04-02 23:11:19 -06:00
|
|
|
buf = bp->b_addr;
|
|
|
|
buf += xfs_symlink_hdr_set(mp, ip->i_ino, offset,
|
|
|
|
byte_cnt, bp);
|
|
|
|
|
|
|
|
memcpy(buf, cur_chunk, byte_cnt);
|
|
|
|
|
2013-04-02 23:11:18 -06:00
|
|
|
cur_chunk += byte_cnt;
|
2013-04-02 23:11:19 -06:00
|
|
|
pathlen -= byte_cnt;
|
|
|
|
offset += byte_cnt;
|
2013-04-02 23:11:18 -06:00
|
|
|
|
2013-09-01 18:32:00 -06:00
|
|
|
xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);
|
2013-04-02 23:11:19 -06:00
|
|
|
xfs_trans_log_buf(tp, bp, 0, (buf + byte_cnt - 1) -
|
|
|
|
(char *)bp->b_addr);
|
2013-04-02 23:11:18 -06:00
|
|
|
}
|
2013-05-27 00:38:20 -06:00
|
|
|
ASSERT(pathlen == 0);
|
2013-04-02 23:11:18 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the directory entry for the symlink.
|
|
|
|
*/
|
|
|
|
error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
|
2016-08-02 19:19:29 -06:00
|
|
|
&first_block, &dfops, resblks);
|
2013-04-02 23:11:18 -06:00
|
|
|
if (error)
|
2015-02-23 04:38:08 -07:00
|
|
|
goto out_bmap_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
|
|
|
xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a synchronous mount, make sure that the
|
|
|
|
* symlink transaction goes to disk before returning to
|
|
|
|
* the user.
|
|
|
|
*/
|
|
|
|
if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
|
|
|
|
xfs_trans_set_sync(tp);
|
|
|
|
}
|
|
|
|
|
2016-08-02 19:19:29 -06:00
|
|
|
error = xfs_defer_finish(&tp, &dfops, NULL);
|
2015-02-23 04:38:08 -07:00
|
|
|
if (error)
|
|
|
|
goto out_bmap_cancel;
|
|
|
|
|
2015-06-03 21:48:08 -06:00
|
|
|
error = xfs_trans_commit(tp);
|
2015-02-23 04:38:08 -07:00
|
|
|
if (error)
|
|
|
|
goto out_release_inode;
|
|
|
|
|
2013-04-02 23:11:18 -06:00
|
|
|
xfs_qm_dqrele(udqp);
|
|
|
|
xfs_qm_dqrele(gdqp);
|
2013-07-10 23:00:40 -06:00
|
|
|
xfs_qm_dqrele(pdqp);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
*ipp = ip;
|
|
|
|
return 0;
|
|
|
|
|
2015-02-23 04:38:08 -07:00
|
|
|
out_bmap_cancel:
|
2016-08-02 19:19:29 -06:00
|
|
|
xfs_defer_cancel(&dfops);
|
2015-02-23 04:38:08 -07:00
|
|
|
out_trans_cancel:
|
2015-06-03 21:47:56 -06:00
|
|
|
xfs_trans_cancel(tp);
|
2015-02-23 04:38:08 -07:00
|
|
|
out_release_inode:
|
|
|
|
/*
|
|
|
|
* Wait until after the current transaction is aborted to finish the
|
|
|
|
* setup of the inode and release the inode. This prevents recursive
|
|
|
|
* transactions and deadlocks from xfs_inactive.
|
|
|
|
*/
|
|
|
|
if (ip) {
|
|
|
|
xfs_finish_inode_setup(ip);
|
|
|
|
IRELE(ip);
|
|
|
|
}
|
|
|
|
|
2013-04-02 23:11:18 -06:00
|
|
|
xfs_qm_dqrele(udqp);
|
|
|
|
xfs_qm_dqrele(gdqp);
|
2013-07-10 23:00:40 -06:00
|
|
|
xfs_qm_dqrele(pdqp);
|
2013-04-02 23:11:18 -06:00
|
|
|
|
|
|
|
if (unlock_dp_on_error)
|
xfs: stop holding ILOCK over filldir callbacks
The recent change to the readdir locking made in 40194ec ("xfs:
reinstate the ilock in xfs_readdir") for CXFS directory sanity was
probably the wrong thing to do. Deep in the readdir code we
can take page faults in the filldir callback, and so taking a page
fault while holding an inode ilock creates a new set of locking
issues that lockdep warns all over the place about.
The locking order for regular inodes w.r.t. page faults is io_lock
-> pagefault -> mmap_sem -> ilock. The directory readdir code now
triggers ilock -> page fault -> mmap_sem. While we cannot deadlock
at this point, it inverts all the locking patterns that lockdep
normally sees on XFS inodes, and so triggers lockdep. We worked
around this with commit 93a8614 ("xfs: fix directory inode iolock
lockdep false positive"), but that then just moved the lockdep
warning to deeper in the page fault path and triggered on security
inode locks. Fixing the shmem issue there just moved the lockdep
reports somewhere else, and now we are getting false positives from
filesystem freezing annotations getting confused.
Further, if we enter memory reclaim in a readdir path, we now get
lockdep warning about potential deadlocks because the ilock is held
when we enter reclaim. This, again, is different to a regular file
in that we never allow memory reclaim to run while holding the ilock
for regular files. Hence lockdep now throws
ilock->kmalloc->reclaim->ilock warnings.
Basically, the problem is that the ilock is being used to protect
the directory data and the inode metadata, whereas for a regular
file the iolock protects the data and the ilock protects the
metadata. From the VFS perspective, the i_mutex serialises all
accesses to the directory data, and so not holding the ilock for
readdir doesn't matter. The issue is that CXFS doesn't access
directory data via the VFS, so it has no "data serialisaton"
mechanism. Hence we need to hold the IOLOCK in the correct places to
provide this low level directory data access serialisation.
The ilock can then be used just when the extent list needs to be
read, just like we do for regular files. The directory modification
code can take the iolock exclusive when the ilock is also taken,
and this then ensures that readdir is correct excluded while
modifications are in progress.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-18 18:33:00 -06:00
|
|
|
xfs_iunlock(dp, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
|
2013-04-02 23:11:18 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free a symlink that has blocks associated with it.
|
|
|
|
*/
|
2013-06-17 14:35:57 -06:00
|
|
|
STATIC int
|
2013-04-02 23:11:18 -06:00
|
|
|
xfs_inactive_symlink_rmt(
|
2013-09-20 09:06:09 -06:00
|
|
|
struct xfs_inode *ip)
|
2013-04-02 23:11:18 -06:00
|
|
|
{
|
|
|
|
xfs_buf_t *bp;
|
|
|
|
int done;
|
|
|
|
int error;
|
|
|
|
xfs_fsblock_t first_block;
|
2016-08-02 19:19:29 -06:00
|
|
|
struct xfs_defer_ops dfops;
|
2013-04-02 23:11:18 -06:00
|
|
|
int i;
|
|
|
|
xfs_mount_t *mp;
|
|
|
|
xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS];
|
|
|
|
int nmaps;
|
|
|
|
int size;
|
|
|
|
xfs_trans_t *tp;
|
|
|
|
|
|
|
|
mp = ip->i_mount;
|
2013-06-17 14:35:57 -06:00
|
|
|
ASSERT(ip->i_df.if_flags & XFS_IFEXTENTS);
|
2013-04-02 23:11:18 -06:00
|
|
|
/*
|
|
|
|
* We're freeing a symlink that has some
|
|
|
|
* blocks allocated to it. Free the
|
|
|
|
* blocks here. We know that we've got
|
|
|
|
* either 1 or 2 extents and that we can
|
|
|
|
* free them all in one bunmapi call.
|
|
|
|
*/
|
|
|
|
ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
|
|
|
|
|
2016-04-05 17:19:55 -06:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
|
|
|
|
if (error)
|
2013-09-20 09:06:09 -06:00
|
|
|
return error;
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
|
|
|
|
2013-04-02 23:11:18 -06:00
|
|
|
/*
|
|
|
|
* Lock the inode, fix the size, and join it to the transaction.
|
|
|
|
* Hold it so in the normal path, we still have it locked for
|
|
|
|
* the second transaction. In the error paths we need it
|
|
|
|
* held so the cancel won't rele it, see below.
|
|
|
|
*/
|
|
|
|
size = (int)ip->i_d.di_size;
|
|
|
|
ip->i_d.di_size = 0;
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
/*
|
|
|
|
* Find the block(s) so we can inval and unmap them.
|
|
|
|
*/
|
|
|
|
done = 0;
|
2016-08-02 19:19:29 -06:00
|
|
|
xfs_defer_init(&dfops, &first_block);
|
2013-04-02 23:11:18 -06:00
|
|
|
nmaps = ARRAY_SIZE(mval);
|
2013-04-02 23:11:19 -06:00
|
|
|
error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size),
|
2013-04-02 23:11:18 -06:00
|
|
|
mval, &nmaps, 0);
|
|
|
|
if (error)
|
2013-09-20 09:06:09 -06:00
|
|
|
goto error_trans_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
/*
|
2013-04-02 23:11:19 -06:00
|
|
|
* Invalidate the block(s). No validation is done.
|
2013-04-02 23:11:18 -06:00
|
|
|
*/
|
|
|
|
for (i = 0; i < nmaps; i++) {
|
|
|
|
bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
|
|
|
|
XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
|
|
|
|
XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
|
|
|
|
if (!bp) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENOMEM;
|
2013-09-20 09:06:09 -06:00
|
|
|
goto error_bmap_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
}
|
|
|
|
xfs_trans_binval(tp, bp);
|
|
|
|
}
|
|
|
|
/*
|
2016-08-02 19:19:29 -06:00
|
|
|
* Unmap the dead block(s) to the dfops.
|
2013-04-02 23:11:18 -06:00
|
|
|
*/
|
2015-07-28 19:51:01 -06:00
|
|
|
error = xfs_bunmapi(tp, ip, 0, size, 0, nmaps,
|
2016-08-02 19:19:29 -06:00
|
|
|
&first_block, &dfops, &done);
|
2013-09-20 09:06:09 -06:00
|
|
|
if (error)
|
|
|
|
goto error_bmap_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
ASSERT(done);
|
|
|
|
/*
|
|
|
|
* Commit the first transaction. This logs the EFI and the inode.
|
|
|
|
*/
|
2016-08-02 19:19:29 -06:00
|
|
|
error = xfs_defer_finish(&tp, &dfops, ip);
|
2013-09-20 09:06:09 -06:00
|
|
|
if (error)
|
|
|
|
goto error_bmap_cancel;
|
2013-04-02 23:11:18 -06:00
|
|
|
/*
|
|
|
|
* The first xact was committed, so add the inode to the new one.
|
|
|
|
* Mark it dirty so it will be logged and moved forward in the log as
|
|
|
|
* part of every commit.
|
|
|
|
*/
|
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
/*
|
|
|
|
* Commit the transaction containing extent freeing and EFDs.
|
|
|
|
*/
|
2015-06-03 21:48:08 -06:00
|
|
|
error = xfs_trans_commit(tp);
|
2013-04-02 23:11:18 -06:00
|
|
|
if (error) {
|
|
|
|
ASSERT(XFS_FORCED_SHUTDOWN(mp));
|
2013-09-20 09:06:09 -06:00
|
|
|
goto error_unlock;
|
2013-04-02 23:11:18 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove the memory for extent descriptions (just bookkeeping).
|
|
|
|
*/
|
|
|
|
if (ip->i_df.if_bytes)
|
|
|
|
xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
|
|
|
|
ASSERT(ip->i_df.if_bytes == 0);
|
|
|
|
|
2013-09-20 09:06:09 -06:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2013-04-02 23:11:18 -06:00
|
|
|
return 0;
|
|
|
|
|
2013-09-20 09:06:09 -06:00
|
|
|
error_bmap_cancel:
|
2016-08-02 19:19:29 -06:00
|
|
|
xfs_defer_cancel(&dfops);
|
2013-09-20 09:06:09 -06:00
|
|
|
error_trans_cancel:
|
2015-06-03 21:47:56 -06:00
|
|
|
xfs_trans_cancel(tp);
|
2013-09-20 09:06:09 -06:00
|
|
|
error_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2013-04-02 23:11:18 -06:00
|
|
|
return error;
|
|
|
|
}
|
2013-06-17 14:35:57 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_inactive_symlink - free a symlink
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_inactive_symlink(
|
2013-09-20 09:06:09 -06:00
|
|
|
struct xfs_inode *ip)
|
2013-06-17 14:35:57 -06:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
int pathlen;
|
|
|
|
|
|
|
|
trace_xfs_inactive_symlink(ip);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2013-06-17 14:35:57 -06:00
|
|
|
|
2013-09-20 09:06:09 -06:00
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
|
2013-06-17 14:35:57 -06:00
|
|
|
/*
|
|
|
|
* Zero length symlinks _can_ exist.
|
|
|
|
*/
|
|
|
|
pathlen = (int)ip->i_d.di_size;
|
2013-09-20 09:06:09 -06:00
|
|
|
if (!pathlen) {
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2013-06-17 14:35:57 -06:00
|
|
|
return 0;
|
2013-09-20 09:06:09 -06:00
|
|
|
}
|
2013-06-17 14:35:57 -06:00
|
|
|
|
|
|
|
if (pathlen < 0 || pathlen > MAXPATHLEN) {
|
|
|
|
xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)",
|
|
|
|
__func__, (unsigned long long)ip->i_ino, pathlen);
|
2013-09-20 09:06:09 -06:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2013-06-17 14:35:57 -06:00
|
|
|
ASSERT(0);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2013-06-17 14:35:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ip->i_df.if_flags & XFS_IFINLINE) {
|
2013-09-20 09:06:09 -06:00
|
|
|
if (ip->i_df.if_bytes > 0)
|
2013-06-17 14:35:57 -06:00
|
|
|
xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
|
|
|
|
XFS_DATA_FORK);
|
2013-09-20 09:06:09 -06:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2013-06-17 14:35:57 -06:00
|
|
|
ASSERT(ip->i_df.if_bytes == 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-20 09:06:09 -06:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
|
2013-06-17 14:35:57 -06:00
|
|
|
/* remove the remote symlink */
|
2013-09-20 09:06:09 -06:00
|
|
|
return xfs_inactive_symlink_rmt(ip);
|
2013-06-17 14:35:57 -06:00
|
|
|
}
|