vxfs_inode.c 9.21 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 * Copyright (c) 2000-2001 Christoph Hellwig.
3
 * Copyright (c) 2016 Krzysztof Blaszkowski
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL").
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Veritas filesystem driver - inode routines.
 */
#include <linux/fs.h>
#include <linux/buffer_head.h>
#include <linux/pagemap.h>
#include <linux/kernel.h>
#include <linux/slab.h>
39
#include <linux/namei.h>
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

#include "vxfs.h"
#include "vxfs_inode.h"
#include "vxfs_extern.h"


#ifdef DIAGNOSTIC
/*
 * Dump inode contents (partially).
 */
void
vxfs_dumpi(struct vxfs_inode_info *vip, ino_t ino)
{
	printk(KERN_DEBUG "\n\n");
	if (ino)
		printk(KERN_DEBUG "dumping vxfs inode %ld\n", ino);
	else
		printk(KERN_DEBUG "dumping unknown vxfs inode\n");

	printk(KERN_DEBUG "---------------------------\n");
	printk(KERN_DEBUG "mode is %x\n", vip->vii_mode);
	printk(KERN_DEBUG "nlink:%u, uid:%u, gid:%u\n",
			vip->vii_nlink, vip->vii_uid, vip->vii_gid);
	printk(KERN_DEBUG "size:%Lx, blocks:%u\n",
			vip->vii_size, vip->vii_blocks);
	printk(KERN_DEBUG "orgtype:%u\n", vip->vii_orgtype);
}
#endif

69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
/**
 * vxfs_transmod - mode for a VxFS inode
 * @vip:	VxFS inode
 *
 * Description:
 *  vxfs_transmod returns a Linux mode_t for a given
 *  VxFS inode structure.
 */
static __inline__ umode_t
vxfs_transmod(struct vxfs_inode_info *vip)
{
	umode_t			ret = vip->vii_mode & ~VXFS_TYPE_MASK;

	if (VXFS_ISFIFO(vip))
		ret |= S_IFIFO;
	if (VXFS_ISCHR(vip))
		ret |= S_IFCHR;
	if (VXFS_ISDIR(vip))
		ret |= S_IFDIR;
	if (VXFS_ISBLK(vip))
		ret |= S_IFBLK;
	if (VXFS_ISLNK(vip))
		ret |= S_IFLNK;
	if (VXFS_ISREG(vip))
		ret |= S_IFREG;
	if (VXFS_ISSOC(vip))
		ret |= S_IFSOCK;

	return (ret);
}

100 101 102
static inline void dip2vip_cpy(struct vxfs_sb_info *sbi,
		struct vxfs_inode_info *vip, struct vxfs_dinode *dip)
{
103 104
	struct inode *inode = &vip->vfs_inode;

105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
	vip->vii_mode = fs32_to_cpu(sbi, dip->vdi_mode);
	vip->vii_nlink = fs32_to_cpu(sbi, dip->vdi_nlink);
	vip->vii_uid = fs32_to_cpu(sbi, dip->vdi_uid);
	vip->vii_gid = fs32_to_cpu(sbi, dip->vdi_gid);
	vip->vii_size = fs64_to_cpu(sbi, dip->vdi_size);
	vip->vii_atime = fs32_to_cpu(sbi, dip->vdi_atime);
	vip->vii_autime = fs32_to_cpu(sbi, dip->vdi_autime);
	vip->vii_mtime = fs32_to_cpu(sbi, dip->vdi_mtime);
	vip->vii_mutime = fs32_to_cpu(sbi, dip->vdi_mutime);
	vip->vii_ctime = fs32_to_cpu(sbi, dip->vdi_ctime);
	vip->vii_cutime = fs32_to_cpu(sbi, dip->vdi_cutime);
	vip->vii_orgtype = dip->vdi_orgtype;

	vip->vii_blocks = fs32_to_cpu(sbi, dip->vdi_blocks);
	vip->vii_gen = fs32_to_cpu(sbi, dip->vdi_gen);

	if (VXFS_ISDIR(vip))
		vip->vii_dotdot = fs32_to_cpu(sbi, dip->vdi_dotdot);
	else if (!VXFS_ISREG(vip) && !VXFS_ISLNK(vip))
		vip->vii_rdev = fs32_to_cpu(sbi, dip->vdi_rdev);

	/* don't endian swap the fields that differ by orgtype */
	memcpy(&vip->vii_org, &dip->vdi_org, sizeof(vip->vii_org));
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144

	inode->i_mode = vxfs_transmod(vip);
	i_uid_write(inode, (uid_t)vip->vii_uid);
	i_gid_write(inode, (gid_t)vip->vii_gid);

	set_nlink(inode, vip->vii_nlink);
	inode->i_size = vip->vii_size;

	inode->i_atime.tv_sec = vip->vii_atime;
	inode->i_ctime.tv_sec = vip->vii_ctime;
	inode->i_mtime.tv_sec = vip->vii_mtime;
	inode->i_atime.tv_nsec = 0;
	inode->i_ctime.tv_nsec = 0;
	inode->i_mtime.tv_nsec = 0;

	inode->i_blocks = vip->vii_blocks;
	inode->i_generation = vip->vii_gen;
145
}
Linus Torvalds's avatar
Linus Torvalds committed
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162

/**
 * vxfs_blkiget - find inode based on extent #
 * @sbp:	superblock of the filesystem we search in
 * @extent:	number of the extent to search
 * @ino:	inode number to search
 *
 * Description:
 *  vxfs_blkiget searches inode @ino in the filesystem described by
 *  @sbp in the extent @extent.
 *  Returns the matching VxFS inode on success, else a NULL pointer.
 *
 * NOTE:
 *  While __vxfs_iget uses the pagecache vxfs_blkiget uses the
 *  buffercache.  This function should not be used outside the
 *  read_super() method, otherwise the data may be incoherent.
 */
163
struct inode *
Linus Torvalds's avatar
Linus Torvalds committed
164 165 166
vxfs_blkiget(struct super_block *sbp, u_long extent, ino_t ino)
{
	struct buffer_head		*bp;
167
	struct inode			*inode;
Linus Torvalds's avatar
Linus Torvalds committed
168 169
	u_long				block, offset;

170 171 172 173 174
	inode = new_inode(sbp);
	if (!inode)
		return NULL;
	inode->i_ino = get_next_ino();

Linus Torvalds's avatar
Linus Torvalds committed
175 176 177 178
	block = extent + ((ino * VXFS_ISIZE) / sbp->s_blocksize);
	offset = ((ino % (sbp->s_blocksize / VXFS_ISIZE)) * VXFS_ISIZE);
	bp = sb_bread(sbp, block);

179
	if (bp && buffer_mapped(bp)) {
180
		struct vxfs_inode_info	*vip = VXFS_INO(inode);
Linus Torvalds's avatar
Linus Torvalds committed
181 182 183
		struct vxfs_dinode	*dip;

		dip = (struct vxfs_dinode *)(bp->b_data + offset);
184
		dip2vip_cpy(VXFS_SBI(sbp), vip, dip);
185
		vip->vfs_inode.i_mapping->a_ops = &vxfs_aops;
Linus Torvalds's avatar
Linus Torvalds committed
186 187 188 189
#ifdef DIAGNOSTIC
		vxfs_dumpi(vip, ino);
#endif
		brelse(bp);
190
		return inode;
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194
	}

	printk(KERN_WARNING "vxfs: unable to read block %ld\n", block);
	brelse(bp);
195
	iput(inode);
Linus Torvalds's avatar
Linus Torvalds committed
196 197 198 199 200 201
	return NULL;
}

/**
 * __vxfs_iget - generic find inode facility
 * @ilistp:		inode list
202 203
 * @vip:		VxFS inode to fill in
 * @ino:		inode number
Linus Torvalds's avatar
Linus Torvalds committed
204 205 206 207
 *
 * Description:
 *  Search the for inode number @ino in the filesystem
 *  described by @sbp.  Use the specified inode table (@ilistp).
208
 *  Returns the matching inode on success, else an error code.
Linus Torvalds's avatar
Linus Torvalds committed
209
 */
210 211
static int
__vxfs_iget(struct inode *ilistp, struct vxfs_inode_info *vip, ino_t ino)
Linus Torvalds's avatar
Linus Torvalds committed
212 213 214 215 216 217 218 219 220 221 222 223
{
	struct page			*pp;
	u_long				offset;

	offset = (ino % (PAGE_SIZE / VXFS_ISIZE)) * VXFS_ISIZE;
	pp = vxfs_get_page(ilistp->i_mapping, ino * VXFS_ISIZE / PAGE_SIZE);

	if (!IS_ERR(pp)) {
		struct vxfs_dinode	*dip;
		caddr_t			kaddr = (char *)page_address(pp);

		dip = (struct vxfs_dinode *)(kaddr + offset);
224
		dip2vip_cpy(VXFS_SBI(ilistp->i_sb), vip, dip);
225
		vip->vfs_inode.i_mapping->a_ops = &vxfs_aops;
Linus Torvalds's avatar
Linus Torvalds committed
226 227 228 229
#ifdef DIAGNOSTIC
		vxfs_dumpi(vip, ino);
#endif
		vxfs_put_page(pp);
230
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
231 232
	}

233 234 235
	printk(KERN_WARNING "vxfs: error on page 0x%p for inode %ld\n",
		pp, (unsigned long)ino);
	return PTR_ERR(pp);
Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239 240 241 242 243 244 245
}

/**
 * vxfs_stiget - find inode using the structural inode list
 * @sbp:	VFS superblock
 * @ino:	inode #
 *
 * Description:
 *  Find inode @ino in the filesystem described by @sbp using
 *  the structural inode list.
246
 *  Returns the matching inode on success, else a NULL pointer.
Linus Torvalds's avatar
Linus Torvalds committed
247
 */
248
struct inode *
Linus Torvalds's avatar
Linus Torvalds committed
249 250
vxfs_stiget(struct super_block *sbp, ino_t ino)
{
251
	struct inode *inode;
252
	int error;
253

254
	inode = new_inode(sbp);
255
	if (!inode)
256 257
		return NULL;
	inode->i_ino = get_next_ino();
Linus Torvalds's avatar
Linus Torvalds committed
258

259 260 261 262
	error = __vxfs_iget(VXFS_SBI(sbp)->vsi_stilist, VXFS_INO(inode), ino);
	if (error) {
		iput(inode);
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
263
	}
264 265

	return inode;
Linus Torvalds's avatar
Linus Torvalds committed
266 267 268
}

/**
269 270 271
 * vxfs_iget - get an inode
 * @sbp:	the superblock to get the inode for
 * @ino:	the number of the inode to get
Linus Torvalds's avatar
Linus Torvalds committed
272 273
 *
 * Description:
274 275
 *  vxfs_read_inode creates an inode, reads the disk inode for @ino and fills
 *  in all relevant fields in the new inode.
Linus Torvalds's avatar
Linus Torvalds committed
276
 */
277 278
struct inode *
vxfs_iget(struct super_block *sbp, ino_t ino)
Linus Torvalds's avatar
Linus Torvalds committed
279 280
{
	struct vxfs_inode_info		*vip;
281
	const struct address_space_operations	*aops;
282
	struct inode *ip;
283
	int error;
284 285 286 287 288 289 290

	ip = iget_locked(sbp, ino);
	if (!ip)
		return ERR_PTR(-ENOMEM);
	if (!(ip->i_state & I_NEW))
		return ip;

291 292 293
	vip = VXFS_INO(ip);
	error = __vxfs_iget(VXFS_SBI(sbp)->vsi_ilist, vip, ino);
	if (error) {
294
		iget_failed(ip);
295
		return ERR_PTR(error);
296
	}
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299 300 301 302 303

	if (VXFS_ISIMMED(vip))
		aops = &vxfs_immed_aops;
	else
		aops = &vxfs_aops;

	if (S_ISREG(ip->i_mode)) {
304
		ip->i_fop = &generic_ro_fops;
Linus Torvalds's avatar
Linus Torvalds committed
305 306 307 308 309 310 311 312
		ip->i_mapping->a_ops = aops;
	} else if (S_ISDIR(ip->i_mode)) {
		ip->i_op = &vxfs_dir_inode_ops;
		ip->i_fop = &vxfs_dir_operations;
		ip->i_mapping->a_ops = aops;
	} else if (S_ISLNK(ip->i_mode)) {
		if (!VXFS_ISIMMED(vip)) {
			ip->i_op = &page_symlink_inode_operations;
313
			inode_nohighmem(ip);
Linus Torvalds's avatar
Linus Torvalds committed
314
			ip->i_mapping->a_ops = &vxfs_aops;
315
		} else {
316 317 318 319
			ip->i_op = &simple_symlink_inode_operations;
			ip->i_link = vip->vii_immed.vi_immed;
			nd_terminate_link(ip->i_link, ip->i_size,
					  sizeof(vip->vii_immed.vi_immed) - 1);
320
		}
Linus Torvalds's avatar
Linus Torvalds committed
321 322 323
	} else
		init_special_inode(ip, ip->i_mode, old_decode_dev(vip->vii_rdev));

324 325
	unlock_new_inode(ip);
	return ip;
Linus Torvalds's avatar
Linus Torvalds committed
326 327 328
}

/**
329
 * vxfs_evict_inode - remove inode from main memory
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332
 * @ip:		inode to discard.
 *
 * Description:
333
 *  vxfs_evict_inode() is called on the final iput and frees the private
Linus Torvalds's avatar
Linus Torvalds committed
334 335 336
 *  inode area.
 */
void
337
vxfs_evict_inode(struct inode *ip)
Linus Torvalds's avatar
Linus Torvalds committed
338
{
339
	truncate_inode_pages_final(&ip->i_data);
340
	clear_inode(ip);
Linus Torvalds's avatar
Linus Torvalds committed
341
}