1 /* 2 * Copyright (c) 2000-2006 Silicon Graphics, Inc. 3 * Copyright (c) 2012-2013 Red Hat, Inc. 4 * All rights reserved. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it would be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 */ 19 #include "xfs.h" 20 #include "xfs_fs.h" 21 #include "xfs_format.h" 22 #include "xfs_log_format.h" 23 #include "xfs_shared.h" 24 #include "xfs_trans_resv.h" 25 #include "xfs_mount.h" 26 #include "xfs_bmap_btree.h" 27 #include "xfs_inode.h" 28 #include "xfs_error.h" 29 #include "xfs_trace.h" 30 #include "xfs_symlink.h" 31 #include "xfs_cksum.h" 32 #include "xfs_trans.h" 33 #include "xfs_buf_item.h" 34 #include "xfs_log.h" 35 36 37 /* 38 * Each contiguous block has a header, so it is not just a simple pathlen 39 * to FSB conversion. 40 */ 41 int 42 xfs_symlink_blocks( 43 struct xfs_mount *mp, 44 int pathlen) 45 { 46 int buflen = XFS_SYMLINK_BUF_SPACE(mp, mp->m_sb.sb_blocksize); 47 48 return (pathlen + buflen - 1) / buflen; 49 } 50 51 int 52 xfs_symlink_hdr_set( 53 struct xfs_mount *mp, 54 xfs_ino_t ino, 55 uint32_t offset, 56 uint32_t size, 57 struct xfs_buf *bp) 58 { 59 struct xfs_dsymlink_hdr *dsl = bp->b_addr; 60 61 if (!xfs_sb_version_hascrc(&mp->m_sb)) 62 return 0; 63 64 memset(dsl, 0, sizeof(struct xfs_dsymlink_hdr)); 65 dsl->sl_magic = cpu_to_be32(XFS_SYMLINK_MAGIC); 66 dsl->sl_offset = cpu_to_be32(offset); 67 dsl->sl_bytes = cpu_to_be32(size); 68 uuid_copy(&dsl->sl_uuid, &mp->m_sb.sb_meta_uuid); 69 dsl->sl_owner = cpu_to_be64(ino); 70 dsl->sl_blkno = cpu_to_be64(bp->b_bn); 71 bp->b_ops = &xfs_symlink_buf_ops; 72 73 return sizeof(struct xfs_dsymlink_hdr); 74 } 75 76 /* 77 * Checking of the symlink header is split into two parts. the verifier does 78 * CRC, location and bounds checking, the unpacking function checks the path 79 * parameters and owner. 80 */ 81 bool 82 xfs_symlink_hdr_ok( 83 xfs_ino_t ino, 84 uint32_t offset, 85 uint32_t size, 86 struct xfs_buf *bp) 87 { 88 struct xfs_dsymlink_hdr *dsl = bp->b_addr; 89 90 if (offset != be32_to_cpu(dsl->sl_offset)) 91 return false; 92 if (size != be32_to_cpu(dsl->sl_bytes)) 93 return false; 94 if (ino != be64_to_cpu(dsl->sl_owner)) 95 return false; 96 97 /* ok */ 98 return true; 99 } 100 101 static xfs_failaddr_t 102 xfs_symlink_verify( 103 struct xfs_buf *bp) 104 { 105 struct xfs_mount *mp = bp->b_target->bt_mount; 106 struct xfs_dsymlink_hdr *dsl = bp->b_addr; 107 108 if (!xfs_sb_version_hascrc(&mp->m_sb)) 109 return __this_address; 110 if (dsl->sl_magic != cpu_to_be32(XFS_SYMLINK_MAGIC)) 111 return __this_address; 112 if (!uuid_equal(&dsl->sl_uuid, &mp->m_sb.sb_meta_uuid)) 113 return __this_address; 114 if (bp->b_bn != be64_to_cpu(dsl->sl_blkno)) 115 return __this_address; 116 if (be32_to_cpu(dsl->sl_offset) + 117 be32_to_cpu(dsl->sl_bytes) >= XFS_SYMLINK_MAXLEN) 118 return __this_address; 119 if (dsl->sl_owner == 0) 120 return __this_address; 121 if (!xfs_log_check_lsn(mp, be64_to_cpu(dsl->sl_lsn))) 122 return __this_address; 123 124 return NULL; 125 } 126 127 static void 128 xfs_symlink_read_verify( 129 struct xfs_buf *bp) 130 { 131 struct xfs_mount *mp = bp->b_target->bt_mount; 132 xfs_failaddr_t fa; 133 134 /* no verification of non-crc buffers */ 135 if (!xfs_sb_version_hascrc(&mp->m_sb)) 136 return; 137 138 if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF)) 139 xfs_verifier_error(bp, -EFSBADCRC, __this_address); 140 else { 141 fa = xfs_symlink_verify(bp); 142 if (fa) 143 xfs_verifier_error(bp, -EFSCORRUPTED, fa); 144 } 145 } 146 147 static void 148 xfs_symlink_write_verify( 149 struct xfs_buf *bp) 150 { 151 struct xfs_mount *mp = bp->b_target->bt_mount; 152 struct xfs_buf_log_item *bip = bp->b_log_item; 153 xfs_failaddr_t fa; 154 155 /* no verification of non-crc buffers */ 156 if (!xfs_sb_version_hascrc(&mp->m_sb)) 157 return; 158 159 fa = xfs_symlink_verify(bp); 160 if (fa) { 161 xfs_verifier_error(bp, -EFSCORRUPTED, fa); 162 return; 163 } 164 165 if (bip) { 166 struct xfs_dsymlink_hdr *dsl = bp->b_addr; 167 dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn); 168 } 169 xfs_buf_update_cksum(bp, XFS_SYMLINK_CRC_OFF); 170 } 171 172 const struct xfs_buf_ops xfs_symlink_buf_ops = { 173 .name = "xfs_symlink", 174 .verify_read = xfs_symlink_read_verify, 175 .verify_write = xfs_symlink_write_verify, 176 .verify_struct = xfs_symlink_verify, 177 }; 178 179 void 180 xfs_symlink_local_to_remote( 181 struct xfs_trans *tp, 182 struct xfs_buf *bp, 183 struct xfs_inode *ip, 184 struct xfs_ifork *ifp) 185 { 186 struct xfs_mount *mp = ip->i_mount; 187 char *buf; 188 189 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF); 190 191 if (!xfs_sb_version_hascrc(&mp->m_sb)) { 192 bp->b_ops = NULL; 193 memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes); 194 xfs_trans_log_buf(tp, bp, 0, ifp->if_bytes - 1); 195 return; 196 } 197 198 /* 199 * As this symlink fits in an inode literal area, it must also fit in 200 * the smallest buffer the filesystem supports. 201 */ 202 ASSERT(BBTOB(bp->b_length) >= 203 ifp->if_bytes + sizeof(struct xfs_dsymlink_hdr)); 204 205 bp->b_ops = &xfs_symlink_buf_ops; 206 207 buf = bp->b_addr; 208 buf += xfs_symlink_hdr_set(mp, ip->i_ino, 0, ifp->if_bytes, bp); 209 memcpy(buf, ifp->if_u1.if_data, ifp->if_bytes); 210 xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsymlink_hdr) + 211 ifp->if_bytes - 1); 212 } 213 214 /* Verify the consistency of an inline symlink. */ 215 xfs_failaddr_t 216 xfs_symlink_shortform_verify( 217 struct xfs_inode *ip) 218 { 219 char *sfp; 220 char *endp; 221 struct xfs_ifork *ifp; 222 int size; 223 224 ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_LOCAL); 225 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK); 226 sfp = (char *)ifp->if_u1.if_data; 227 size = ifp->if_bytes; 228 endp = sfp + size; 229 230 /* Zero length symlinks can exist while we're deleting a remote one. */ 231 if (size == 0) 232 return NULL; 233 234 /* No negative sizes or overly long symlink targets. */ 235 if (size < 0 || size > XFS_SYMLINK_MAXLEN) 236 return __this_address; 237 238 /* No NULLs in the target either. */ 239 if (memchr(sfp, 0, size - 1)) 240 return __this_address; 241 242 /* We /did/ null-terminate the buffer, right? */ 243 if (*endp != 0) 244 return __this_address; 245 return NULL; 246 } 247