1 /*
2  * Copyright (c) 2000-2001 Christoph Hellwig.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions, and the following disclaimer,
10  *    without modification.
11  * 2. The name of the author may not be used to endorse or promote products
12  *    derived from this software without specific prior written permission.
13  *
14  * Alternatively, this software may be distributed under the terms of the
15  * GNU General Public License ("GPL").
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 /*
31  * Veritas filesystem driver - filesystem to disk block mapping.
32  */
33 #include <linux/fs.h>
34 #include <linux/buffer_head.h>
35 #include <linux/kernel.h>
36 
37 #include "vxfs.h"
38 #include "vxfs_inode.h"
39 #include "vxfs_extern.h"
40 
41 
42 #ifdef DIAGNOSTIC
43 static void
vxfs_typdump(struct vxfs_typed * typ)44 vxfs_typdump(struct vxfs_typed *typ)
45 {
46 	printk(KERN_DEBUG "type=%Lu ", typ->vt_hdr >> VXFS_TYPED_TYPESHIFT);
47 	printk("offset=%Lx ", typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
48 	printk("block=%x ", typ->vt_block);
49 	printk("size=%x\n", typ->vt_size);
50 }
51 #endif
52 
53 /**
54  * vxfs_bmap_ext4 - do bmap for ext4 extents
55  * @ip:		pointer to the inode we do bmap for
56  * @iblock:	logical block.
57  *
58  * Description:
59  *   vxfs_bmap_ext4 performs the bmap operation for inodes with
60  *   ext4-style extents (which are much like the traditional UNIX
61  *   inode organisation).
62  *
63  * Returns:
64  *   The physical block number on success, else Zero.
65  */
66 static daddr_t
vxfs_bmap_ext4(struct inode * ip,long bn)67 vxfs_bmap_ext4(struct inode *ip, long bn)
68 {
69 	struct super_block *sb = ip->i_sb;
70 	struct vxfs_inode_info *vip = VXFS_INO(ip);
71 	unsigned long bsize = sb->s_blocksize;
72 	u32 indsize = vip->vii_ext4.ve4_indsize;
73 	int i;
74 
75 	if (indsize > sb->s_blocksize)
76 		goto fail_size;
77 
78 	for (i = 0; i < VXFS_NDADDR; i++) {
79 		struct direct *d = vip->vii_ext4.ve4_direct + i;
80 		if (bn >= 0 && bn < d->size)
81 			return (bn + d->extent);
82 		bn -= d->size;
83 	}
84 
85 	if ((bn / (indsize * indsize * bsize / 4)) == 0) {
86 		struct buffer_head *buf;
87 		daddr_t	bno;
88 		u32 *indir;
89 
90 		buf = sb_bread(sb, vip->vii_ext4.ve4_indir[0]);
91 		if (!buf || !buffer_mapped(buf))
92 			goto fail_buf;
93 
94 		indir = (u32 *)buf->b_data;
95 		bno = indir[(bn/indsize) % (indsize*bn)] + (bn%indsize);
96 
97 		brelse(buf);
98 		return bno;
99 	} else
100 		printk(KERN_WARNING "no matching indir?");
101 
102 	return 0;
103 
104 fail_size:
105 	printk("vxfs: indirect extent too big!\n");
106 fail_buf:
107 	return 0;
108 }
109 
110 /**
111  * vxfs_bmap_indir - recursion for vxfs_bmap_typed
112  * @ip:		pointer to the inode we do bmap for
113  * @indir:	indirect block we start reading at
114  * @size:	size of the typed area to search
115  * @block:	partially result from further searches
116  *
117  * Description:
118  *   vxfs_bmap_indir reads a &struct vxfs_typed at @indir
119  *   and performs the type-defined action.
120  *
121  * Return Value:
122  *   The physical block number on success, else Zero.
123  *
124  * Note:
125  *   Kernelstack is rare.  Unrecurse?
126  */
127 static daddr_t
vxfs_bmap_indir(struct inode * ip,long indir,int size,long block)128 vxfs_bmap_indir(struct inode *ip, long indir, int size, long block)
129 {
130 	struct buffer_head		*bp = NULL;
131 	daddr_t				pblock = 0;
132 	int				i;
133 
134 	for (i = 0; i < size * VXFS_TYPED_PER_BLOCK(ip->i_sb); i++) {
135 		struct vxfs_typed	*typ;
136 		int64_t			off;
137 
138 		bp = sb_bread(ip->i_sb,
139 				indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb)));
140 		if (!bp || !buffer_mapped(bp))
141 			return 0;
142 
143 		typ = ((struct vxfs_typed *)bp->b_data) +
144 			(i % VXFS_TYPED_PER_BLOCK(ip->i_sb));
145 		off = (typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
146 
147 		if (block < off) {
148 			brelse(bp);
149 			continue;
150 		}
151 
152 		switch ((u_int32_t)(typ->vt_hdr >> VXFS_TYPED_TYPESHIFT)) {
153 		case VXFS_TYPED_INDIRECT:
154 			pblock = vxfs_bmap_indir(ip, typ->vt_block,
155 					typ->vt_size, block - off);
156 			if (pblock == -2)
157 				break;
158 			goto out;
159 		case VXFS_TYPED_DATA:
160 			if ((block - off) >= typ->vt_size)
161 				break;
162 			pblock = (typ->vt_block + block - off);
163 			goto out;
164 		case VXFS_TYPED_INDIRECT_DEV4:
165 		case VXFS_TYPED_DATA_DEV4: {
166 			struct vxfs_typed_dev4	*typ4 =
167 				(struct vxfs_typed_dev4 *)typ;
168 
169 			printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
170 			printk(KERN_INFO "block: %Lu\tsize: %Ld\tdev: %d\n",
171 			       (unsigned long long) typ4->vd4_block,
172 			       (unsigned long long) typ4->vd4_size,
173 			       typ4->vd4_dev);
174 			goto fail;
175 		}
176 		default:
177 			BUG();
178 		}
179 		brelse(bp);
180 	}
181 
182 fail:
183 	pblock = 0;
184 out:
185 	brelse(bp);
186 	return (pblock);
187 }
188 
189 /**
190  * vxfs_bmap_typed - bmap for typed extents
191  * @ip:		pointer to the inode we do bmap for
192  * @iblock:	logical block
193  *
194  * Description:
195  *   Performs the bmap operation for typed extents.
196  *
197  * Return Value:
198  *   The physical block number on success, else Zero.
199  */
200 static daddr_t
vxfs_bmap_typed(struct inode * ip,long iblock)201 vxfs_bmap_typed(struct inode *ip, long iblock)
202 {
203 	struct vxfs_inode_info		*vip = VXFS_INO(ip);
204 	daddr_t				pblock = 0;
205 	int				i;
206 
207 	for (i = 0; i < VXFS_NTYPED; i++) {
208 		struct vxfs_typed	*typ = vip->vii_org.typed + i;
209 		int64_t			off = (typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
210 
211 #ifdef DIAGNOSTIC
212 		vxfs_typdump(typ);
213 #endif
214 		if (iblock < off)
215 			continue;
216 		switch ((u_int32_t)(typ->vt_hdr >> VXFS_TYPED_TYPESHIFT)) {
217 		case VXFS_TYPED_INDIRECT:
218 			pblock = vxfs_bmap_indir(ip, typ->vt_block,
219 					typ->vt_size, iblock - off);
220 			if (pblock == -2)
221 				break;
222 			return (pblock);
223 		case VXFS_TYPED_DATA:
224 			if ((iblock - off) < typ->vt_size)
225 				return (typ->vt_block + iblock - off);
226 			break;
227 		case VXFS_TYPED_INDIRECT_DEV4:
228 		case VXFS_TYPED_DATA_DEV4: {
229 			struct vxfs_typed_dev4	*typ4 =
230 				(struct vxfs_typed_dev4 *)typ;
231 
232 			printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
233 			printk(KERN_INFO "block: %Lu\tsize: %Ld\tdev: %d\n",
234 			       (unsigned long long) typ4->vd4_block,
235 			       (unsigned long long) typ4->vd4_size,
236 			       typ4->vd4_dev);
237 			return 0;
238 		}
239 		default:
240 			BUG();
241 		}
242 	}
243 
244 	return 0;
245 }
246 
247 /**
248  * vxfs_bmap1 - vxfs-internal bmap operation
249  * @ip:			pointer to the inode we do bmap for
250  * @iblock:		logical block
251  *
252  * Description:
253  *   vxfs_bmap1 perfoms a logical to physical block mapping
254  *   for vxfs-internal purposes.
255  *
256  * Return Value:
257  *   The physical block number on success, else Zero.
258  */
259 daddr_t
vxfs_bmap1(struct inode * ip,long iblock)260 vxfs_bmap1(struct inode *ip, long iblock)
261 {
262 	struct vxfs_inode_info		*vip = VXFS_INO(ip);
263 
264 	if (VXFS_ISEXT4(vip))
265 		return vxfs_bmap_ext4(ip, iblock);
266 	if (VXFS_ISTYPED(vip))
267 		return vxfs_bmap_typed(ip, iblock);
268 	if (VXFS_ISNONE(vip))
269 		goto unsupp;
270 	if (VXFS_ISIMMED(vip))
271 		goto unsupp;
272 
273 	printk(KERN_WARNING "vxfs: inode %ld has no valid orgtype (%x)\n",
274 			ip->i_ino, vip->vii_orgtype);
275 	BUG();
276 
277 unsupp:
278 	printk(KERN_WARNING "vxfs: inode %ld has an unsupported orgtype (%x)\n",
279 			ip->i_ino, vip->vii_orgtype);
280 	return 0;
281 }
282