Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
vxfs_inode.c
Go to the documentation of this file.
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 - inode routines.
32  */
33 #include <linux/fs.h>
34 #include <linux/buffer_head.h>
35 #include <linux/pagemap.h>
36 #include <linux/kernel.h>
37 #include <linux/slab.h>
38 
39 #include "vxfs.h"
40 #include "vxfs_inode.h"
41 #include "vxfs_extern.h"
42 
43 
45 
46 
47 #ifdef DIAGNOSTIC
48 /*
49  * Dump inode contents (partially).
50  */
51 void
53 {
54  printk(KERN_DEBUG "\n\n");
55  if (ino)
56  printk(KERN_DEBUG "dumping vxfs inode %ld\n", ino);
57  else
58  printk(KERN_DEBUG "dumping unknown vxfs inode\n");
59 
60  printk(KERN_DEBUG "---------------------------\n");
61  printk(KERN_DEBUG "mode is %x\n", vip->vii_mode);
62  printk(KERN_DEBUG "nlink:%u, uid:%u, gid:%u\n",
63  vip->vii_nlink, vip->vii_uid, vip->vii_gid);
64  printk(KERN_DEBUG "size:%Lx, blocks:%u\n",
65  vip->vii_size, vip->vii_blocks);
66  printk(KERN_DEBUG "orgtype:%u\n", vip->vii_orgtype);
67 }
68 #endif
69 
70 
87 struct vxfs_inode_info *
89 {
90  struct buffer_head *bp;
92 
93  block = extent + ((ino * VXFS_ISIZE) / sbp->s_blocksize);
94  offset = ((ino % (sbp->s_blocksize / VXFS_ISIZE)) * VXFS_ISIZE);
95  bp = sb_bread(sbp, block);
96 
97  if (bp && buffer_mapped(bp)) {
98  struct vxfs_inode_info *vip;
99  struct vxfs_dinode *dip;
100 
101  if (!(vip = kmem_cache_alloc(vxfs_inode_cachep, GFP_KERNEL)))
102  goto fail;
103  dip = (struct vxfs_dinode *)(bp->b_data + offset);
104  memcpy(vip, dip, sizeof(*vip));
105 #ifdef DIAGNOSTIC
106  vxfs_dumpi(vip, ino);
107 #endif
108  brelse(bp);
109  return (vip);
110  }
111 
112 fail:
113  printk(KERN_WARNING "vxfs: unable to read block %ld\n", block);
114  brelse(bp);
115  return NULL;
116 }
117 
129 static struct vxfs_inode_info *
130 __vxfs_iget(ino_t ino, struct inode *ilistp)
131 {
132  struct page *pp;
133  u_long offset;
134 
135  offset = (ino % (PAGE_SIZE / VXFS_ISIZE)) * VXFS_ISIZE;
136  pp = vxfs_get_page(ilistp->i_mapping, ino * VXFS_ISIZE / PAGE_SIZE);
137 
138  if (!IS_ERR(pp)) {
139  struct vxfs_inode_info *vip;
140  struct vxfs_dinode *dip;
141  caddr_t kaddr = (char *)page_address(pp);
142 
143  if (!(vip = kmem_cache_alloc(vxfs_inode_cachep, GFP_KERNEL)))
144  goto fail;
145  dip = (struct vxfs_dinode *)(kaddr + offset);
146  memcpy(vip, dip, sizeof(*vip));
147 #ifdef DIAGNOSTIC
148  vxfs_dumpi(vip, ino);
149 #endif
150  vxfs_put_page(pp);
151  return (vip);
152  }
153 
154  printk(KERN_WARNING "vxfs: error on page %p\n", pp);
155  return ERR_CAST(pp);
156 
157 fail:
158  printk(KERN_WARNING "vxfs: unable to read inode %ld\n", (unsigned long)ino);
159  vxfs_put_page(pp);
160  return ERR_PTR(-ENOMEM);
161 }
162 
173 struct vxfs_inode_info *
174 vxfs_stiget(struct super_block *sbp, ino_t ino)
175 {
176  struct vxfs_inode_info *vip;
177 
178  vip = __vxfs_iget(ino, VXFS_SBI(sbp)->vsi_stilist);
179  return IS_ERR(vip) ? NULL : vip;
180 }
181 
190 static __inline__ umode_t
191 vxfs_transmod(struct vxfs_inode_info *vip)
192 {
193  umode_t ret = vip->vii_mode & ~VXFS_TYPE_MASK;
194 
195  if (VXFS_ISFIFO(vip))
196  ret |= S_IFIFO;
197  if (VXFS_ISCHR(vip))
198  ret |= S_IFCHR;
199  if (VXFS_ISDIR(vip))
200  ret |= S_IFDIR;
201  if (VXFS_ISBLK(vip))
202  ret |= S_IFBLK;
203  if (VXFS_ISLNK(vip))
204  ret |= S_IFLNK;
205  if (VXFS_ISREG(vip))
206  ret |= S_IFREG;
207  if (VXFS_ISSOC(vip))
208  ret |= S_IFSOCK;
209 
210  return (ret);
211 }
212 
222 static void
223 vxfs_iinit(struct inode *ip, struct vxfs_inode_info *vip)
224 {
225 
226  ip->i_mode = vxfs_transmod(vip);
227  i_uid_write(ip, (uid_t)vip->vii_uid);
228  i_gid_write(ip, (gid_t)vip->vii_gid);
229 
230  set_nlink(ip, vip->vii_nlink);
231  ip->i_size = vip->vii_size;
232 
233  ip->i_atime.tv_sec = vip->vii_atime;
234  ip->i_ctime.tv_sec = vip->vii_ctime;
235  ip->i_mtime.tv_sec = vip->vii_mtime;
236  ip->i_atime.tv_nsec = 0;
237  ip->i_ctime.tv_nsec = 0;
238  ip->i_mtime.tv_nsec = 0;
239 
240  ip->i_blocks = vip->vii_blocks;
241  ip->i_generation = vip->vii_gen;
242 
243  ip->i_private = vip;
244 
245 }
246 
257 struct inode *
259 {
260  struct inode *ip = NULL;
261 
262  if ((ip = new_inode(sbp))) {
263  ip->i_ino = get_next_ino();
264  vxfs_iinit(ip, vip);
265  ip->i_mapping->a_ops = &vxfs_aops;
266  }
267  return (ip);
268 }
269 
277 void
279 {
280  iput(ip);
281 }
282 
292 struct inode *
293 vxfs_iget(struct super_block *sbp, ino_t ino)
294 {
295  struct vxfs_inode_info *vip;
296  const struct address_space_operations *aops;
297  struct inode *ip;
298 
299  ip = iget_locked(sbp, ino);
300  if (!ip)
301  return ERR_PTR(-ENOMEM);
302  if (!(ip->i_state & I_NEW))
303  return ip;
304 
305  vip = __vxfs_iget(ino, VXFS_SBI(sbp)->vsi_ilist);
306  if (IS_ERR(vip)) {
307  iget_failed(ip);
308  return ERR_CAST(vip);
309  }
310 
311  vxfs_iinit(ip, vip);
312 
313  if (VXFS_ISIMMED(vip))
314  aops = &vxfs_immed_aops;
315  else
316  aops = &vxfs_aops;
317 
318  if (S_ISREG(ip->i_mode)) {
319  ip->i_fop = &generic_ro_fops;
320  ip->i_mapping->a_ops = aops;
321  } else if (S_ISDIR(ip->i_mode)) {
322  ip->i_op = &vxfs_dir_inode_ops;
323  ip->i_fop = &vxfs_dir_operations;
324  ip->i_mapping->a_ops = aops;
325  } else if (S_ISLNK(ip->i_mode)) {
326  if (!VXFS_ISIMMED(vip)) {
328  ip->i_mapping->a_ops = &vxfs_aops;
329  } else {
331  vip->vii_immed.vi_immed[ip->i_size] = '\0';
332  }
333  } else
334  init_special_inode(ip, ip->i_mode, old_decode_dev(vip->vii_rdev));
335 
336  unlock_new_inode(ip);
337  return ip;
338 }
339 
340 static void vxfs_i_callback(struct rcu_head *head)
341 {
342  struct inode *inode = container_of(head, struct inode, i_rcu);
343  kmem_cache_free(vxfs_inode_cachep, inode->i_private);
344 }
345 
354 void
356 {
357  truncate_inode_pages(&ip->i_data, 0);
358  clear_inode(ip);
359  call_rcu(&ip->i_rcu, vxfs_i_callback);
360 }