Merge branch 'master' of git://git.kernel.org/pub/scm/fs/xfs/xfs
[kernel.git] / fs / xfs / linux-2.6 / xfs_iops.c
1 /*
2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_acl.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_dir2.h"
28 #include "xfs_alloc.h"
29 #include "xfs_dmapi.h"
30 #include "xfs_quota.h"
31 #include "xfs_mount.h"
32 #include "xfs_bmap_btree.h"
33 #include "xfs_alloc_btree.h"
34 #include "xfs_ialloc_btree.h"
35 #include "xfs_dir2_sf.h"
36 #include "xfs_attr_sf.h"
37 #include "xfs_dinode.h"
38 #include "xfs_inode.h"
39 #include "xfs_bmap.h"
40 #include "xfs_btree.h"
41 #include "xfs_ialloc.h"
42 #include "xfs_rtalloc.h"
43 #include "xfs_error.h"
44 #include "xfs_itable.h"
45 #include "xfs_rw.h"
46 #include "xfs_acl.h"
47 #include "xfs_attr.h"
48 #include "xfs_buf_item.h"
49 #include "xfs_utils.h"
50 #include "xfs_vnodeops.h"
51
52 #include <linux/capability.h>
53 #include <linux/xattr.h>
54 #include <linux/namei.h>
55 #include <linux/posix_acl.h>
56 #include <linux/security.h>
57 #include <linux/falloc.h>
58 #include <linux/fiemap.h>
59
60 /*
61  * Bring the atime in the XFS inode uptodate.
62  * Used before logging the inode to disk or when the Linux inode goes away.
63  */
64 void
65 xfs_synchronize_atime(
66         xfs_inode_t     *ip)
67 {
68         struct inode    *inode = VFS_I(ip);
69
70         if (!(inode->i_state & I_CLEAR)) {
71                 ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
72                 ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
73         }
74 }
75
76 /*
77  * If the linux inode is valid, mark it dirty.
78  * Used when commiting a dirty inode into a transaction so that
79  * the inode will get written back by the linux code
80  */
81 void
82 xfs_mark_inode_dirty_sync(
83         xfs_inode_t     *ip)
84 {
85         struct inode    *inode = VFS_I(ip);
86
87         if (!(inode->i_state & (I_WILL_FREE|I_FREEING|I_CLEAR)))
88                 mark_inode_dirty_sync(inode);
89 }
90
91 /*
92  * Change the requested timestamp in the given inode.
93  * We don't lock across timestamp updates, and we don't log them but
94  * we do record the fact that there is dirty information in core.
95  */
96 void
97 xfs_ichgtime(
98         xfs_inode_t     *ip,
99         int             flags)
100 {
101         struct inode    *inode = VFS_I(ip);
102         timespec_t      tv;
103         int             sync_it = 0;
104
105         tv = current_fs_time(inode->i_sb);
106
107         if ((flags & XFS_ICHGTIME_MOD) &&
108             !timespec_equal(&inode->i_mtime, &tv)) {
109                 inode->i_mtime = tv;
110                 ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
111                 ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
112                 sync_it = 1;
113         }
114         if ((flags & XFS_ICHGTIME_CHG) &&
115             !timespec_equal(&inode->i_ctime, &tv)) {
116                 inode->i_ctime = tv;
117                 ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
118                 ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
119                 sync_it = 1;
120         }
121
122         /*
123          * We update the i_update_core field _after_ changing
124          * the timestamps in order to coordinate properly with
125          * xfs_iflush() so that we don't lose timestamp updates.
126          * This keeps us from having to hold the inode lock
127          * while doing this.  We use the SYNCHRONIZE macro to
128          * ensure that the compiler does not reorder the update
129          * of i_update_core above the timestamp updates above.
130          */
131         if (sync_it) {
132                 SYNCHRONIZE();
133                 ip->i_update_core = 1;
134                 xfs_mark_inode_dirty_sync(ip);
135         }
136 }
137
138 /*
139  * Hook in SELinux.  This is not quite correct yet, what we really need
140  * here (as we do for default ACLs) is a mechanism by which creation of
141  * these attrs can be journalled at inode creation time (along with the
142  * inode, of course, such that log replay can't cause these to be lost).
143  */
144 STATIC int
145 xfs_init_security(
146         struct inode    *inode,
147         struct inode    *dir)
148 {
149         struct xfs_inode *ip = XFS_I(inode);
150         size_t          length;
151         void            *value;
152         char            *name;
153         int             error;
154
155         error = security_inode_init_security(inode, dir, &name,
156                                              &value, &length);
157         if (error) {
158                 if (error == -EOPNOTSUPP)
159                         return 0;
160                 return -error;
161         }
162
163         error = xfs_attr_set(ip, name, value, length, ATTR_SECURE);
164
165         kfree(name);
166         kfree(value);
167         return error;
168 }
169
170 static void
171 xfs_dentry_to_name(
172         struct xfs_name *namep,
173         struct dentry   *dentry)
174 {
175         namep->name = dentry->d_name.name;
176         namep->len = dentry->d_name.len;
177 }
178
179 STATIC void
180 xfs_cleanup_inode(
181         struct inode    *dir,
182         struct inode    *inode,
183         struct dentry   *dentry)
184 {
185         struct xfs_name teardown;
186
187         /* Oh, the horror.
188          * If we can't add the ACL or we fail in
189          * xfs_init_security we must back out.
190          * ENOSPC can hit here, among other things.
191          */
192         xfs_dentry_to_name(&teardown, dentry);
193
194         xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
195         iput(inode);
196 }
197
198 STATIC int
199 xfs_vn_mknod(
200         struct inode    *dir,
201         struct dentry   *dentry,
202         int             mode,
203         dev_t           rdev)
204 {
205         struct inode    *inode;
206         struct xfs_inode *ip = NULL;
207         struct posix_acl *default_acl = NULL;
208         struct xfs_name name;
209         int             error;
210
211         /*
212          * Irix uses Missed'em'V split, but doesn't want to see
213          * the upper 5 bits of (14bit) major.
214          */
215         if (S_ISCHR(mode) || S_ISBLK(mode)) {
216                 if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
217                         return -EINVAL;
218                 rdev = sysv_encode_dev(rdev);
219         } else {
220                 rdev = 0;
221         }
222
223         if (IS_POSIXACL(dir)) {
224                 default_acl = xfs_get_acl(dir, ACL_TYPE_DEFAULT);
225                 if (IS_ERR(default_acl))
226                         return -PTR_ERR(default_acl);
227
228         if (!default_acl)
229                 mode &= ~current_umask();
230         }
231
232         xfs_dentry_to_name(&name, dentry);
233         error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip, NULL);
234         if (unlikely(error))
235                 goto out_free_acl;
236
237         inode = VFS_I(ip);
238
239         error = xfs_init_security(inode, dir);
240         if (unlikely(error))
241                 goto out_cleanup_inode;
242
243         if (default_acl) {
244                 error = -xfs_inherit_acl(inode, default_acl);
245                 if (unlikely(error))
246                         goto out_cleanup_inode;
247                 posix_acl_release(default_acl);
248         }
249
250
251         d_instantiate(dentry, inode);
252         return -error;
253
254  out_cleanup_inode:
255         xfs_cleanup_inode(dir, inode, dentry);
256  out_free_acl:
257         posix_acl_release(default_acl);
258         return -error;
259 }
260
261 STATIC int
262 xfs_vn_create(
263         struct inode    *dir,
264         struct dentry   *dentry,
265         int             mode,
266         struct nameidata *nd)
267 {
268         return xfs_vn_mknod(dir, dentry, mode, 0);
269 }
270
271 STATIC int
272 xfs_vn_mkdir(
273         struct inode    *dir,
274         struct dentry   *dentry,
275         int             mode)
276 {
277         return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
278 }
279
280 STATIC struct dentry *
281 xfs_vn_lookup(
282         struct inode    *dir,
283         struct dentry   *dentry,
284         struct nameidata *nd)
285 {
286         struct xfs_inode *cip;
287         struct xfs_name name;
288         int             error;
289
290         if (dentry->d_name.len >= MAXNAMELEN)
291                 return ERR_PTR(-ENAMETOOLONG);
292
293         xfs_dentry_to_name(&name, dentry);
294         error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
295         if (unlikely(error)) {
296                 if (unlikely(error != ENOENT))
297                         return ERR_PTR(-error);
298                 d_add(dentry, NULL);
299                 return NULL;
300         }
301
302         return d_splice_alias(VFS_I(cip), dentry);
303 }
304
305 STATIC struct dentry *
306 xfs_vn_ci_lookup(
307         struct inode    *dir,
308         struct dentry   *dentry,
309         struct nameidata *nd)
310 {
311         struct xfs_inode *ip;
312         struct xfs_name xname;
313         struct xfs_name ci_name;
314         struct qstr     dname;
315         int             error;
316
317         if (dentry->d_name.len >= MAXNAMELEN)
318                 return ERR_PTR(-ENAMETOOLONG);
319
320         xfs_dentry_to_name(&xname, dentry);
321         error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
322         if (unlikely(error)) {
323                 if (unlikely(error != ENOENT))
324                         return ERR_PTR(-error);
325                 /*
326                  * call d_add(dentry, NULL) here when d_drop_negative_children
327                  * is called in xfs_vn_mknod (ie. allow negative dentries
328                  * with CI filesystems).
329                  */
330                 return NULL;
331         }
332
333         /* if exact match, just splice and exit */
334         if (!ci_name.name)
335                 return d_splice_alias(VFS_I(ip), dentry);
336
337         /* else case-insensitive match... */
338         dname.name = ci_name.name;
339         dname.len = ci_name.len;
340         dentry = d_add_ci(dentry, VFS_I(ip), &dname);
341         kmem_free(ci_name.name);
342         return dentry;
343 }
344
345 STATIC int
346 xfs_vn_link(
347         struct dentry   *old_dentry,
348         struct inode    *dir,
349         struct dentry   *dentry)
350 {
351         struct inode    *inode = old_dentry->d_inode;
352         struct xfs_name name;
353         int             error;
354
355         xfs_dentry_to_name(&name, dentry);
356
357         error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
358         if (unlikely(error))
359                 return -error;
360
361         atomic_inc(&inode->i_count);
362         d_instantiate(dentry, inode);
363         return 0;
364 }
365
366 STATIC int
367 xfs_vn_unlink(
368         struct inode    *dir,
369         struct dentry   *dentry)
370 {
371         struct xfs_name name;
372         int             error;
373
374         xfs_dentry_to_name(&name, dentry);
375
376         error = -xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
377         if (error)
378                 return error;
379
380         /*
381          * With unlink, the VFS makes the dentry "negative": no inode,
382          * but still hashed. This is incompatible with case-insensitive
383          * mode, so invalidate (unhash) the dentry in CI-mode.
384          */
385         if (xfs_sb_version_hasasciici(&XFS_M(dir->i_sb)->m_sb))
386                 d_invalidate(dentry);
387         return 0;
388 }
389
390 STATIC int
391 xfs_vn_symlink(
392         struct inode    *dir,
393         struct dentry   *dentry,
394         const char      *symname)
395 {
396         struct inode    *inode;
397         struct xfs_inode *cip = NULL;
398         struct xfs_name name;
399         int             error;
400         mode_t          mode;
401
402         mode = S_IFLNK |
403                 (irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
404         xfs_dentry_to_name(&name, dentry);
405
406         error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip, NULL);
407         if (unlikely(error))
408                 goto out;
409
410         inode = VFS_I(cip);
411
412         error = xfs_init_security(inode, dir);
413         if (unlikely(error))
414                 goto out_cleanup_inode;
415
416         d_instantiate(dentry, inode);
417         return 0;
418
419  out_cleanup_inode:
420         xfs_cleanup_inode(dir, inode, dentry);
421  out:
422         return -error;
423 }
424
425 STATIC int
426 xfs_vn_rename(
427         struct inode    *odir,
428         struct dentry   *odentry,
429         struct inode    *ndir,
430         struct dentry   *ndentry)
431 {
432         struct inode    *new_inode = ndentry->d_inode;
433         struct xfs_name oname;
434         struct xfs_name nname;
435
436         xfs_dentry_to_name(&oname, odentry);
437         xfs_dentry_to_name(&nname, ndentry);
438
439         return -xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
440                            XFS_I(ndir), &nname, new_inode ?
441                                                 XFS_I(new_inode) : NULL);
442 }
443
444 /*
445  * careful here - this function can get called recursively, so
446  * we need to be very careful about how much stack we use.
447  * uio is kmalloced for this reason...
448  */
449 STATIC void *
450 xfs_vn_follow_link(
451         struct dentry           *dentry,
452         struct nameidata        *nd)
453 {
454         char                    *link;
455         int                     error = -ENOMEM;
456
457         link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
458         if (!link)
459                 goto out_err;
460
461         error = -xfs_readlink(XFS_I(dentry->d_inode), link);
462         if (unlikely(error))
463                 goto out_kfree;
464
465         nd_set_link(nd, link);
466         return NULL;
467
468  out_kfree:
469         kfree(link);
470  out_err:
471         nd_set_link(nd, ERR_PTR(error));
472         return NULL;
473 }
474
475 STATIC void
476 xfs_vn_put_link(
477         struct dentry   *dentry,
478         struct nameidata *nd,
479         void            *p)
480 {
481         char            *s = nd_get_link(nd);
482
483         if (!IS_ERR(s))
484                 kfree(s);
485 }
486
487 STATIC int
488 xfs_vn_permission(
489         struct inode            *inode,
490         int                     mask)
491 {
492         return generic_permission(inode, mask, xfs_check_acl);
493 }
494
495 STATIC int
496 xfs_vn_getattr(
497         struct vfsmount         *mnt,
498         struct dentry           *dentry,
499         struct kstat            *stat)
500 {
501         struct inode            *inode = dentry->d_inode;
502         struct xfs_inode        *ip = XFS_I(inode);
503         struct xfs_mount        *mp = ip->i_mount;
504
505         xfs_itrace_entry(ip);
506
507         if (XFS_FORCED_SHUTDOWN(mp))
508                 return XFS_ERROR(EIO);
509
510         stat->size = XFS_ISIZE(ip);
511         stat->dev = inode->i_sb->s_dev;
512         stat->mode = ip->i_d.di_mode;
513         stat->nlink = ip->i_d.di_nlink;
514         stat->uid = ip->i_d.di_uid;
515         stat->gid = ip->i_d.di_gid;
516         stat->ino = ip->i_ino;
517         stat->atime = inode->i_atime;
518         stat->mtime.tv_sec = ip->i_d.di_mtime.t_sec;
519         stat->mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
520         stat->ctime.tv_sec = ip->i_d.di_ctime.t_sec;
521         stat->ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
522         stat->blocks =
523                 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
524
525
526         switch (inode->i_mode & S_IFMT) {
527         case S_IFBLK:
528         case S_IFCHR:
529                 stat->blksize = BLKDEV_IOSIZE;
530                 stat->rdev = MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
531                                    sysv_minor(ip->i_df.if_u2.if_rdev));
532                 break;
533         default:
534                 if (XFS_IS_REALTIME_INODE(ip)) {
535                         /*
536                          * If the file blocks are being allocated from a
537                          * realtime volume, then return the inode's realtime
538                          * extent size or the realtime volume's extent size.
539                          */
540                         stat->blksize =
541                                 xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog;
542                 } else
543                         stat->blksize = xfs_preferred_iosize(mp);
544                 stat->rdev = 0;
545                 break;
546         }
547
548         return 0;
549 }
550
551 STATIC int
552 xfs_vn_setattr(
553         struct dentry   *dentry,
554         struct iattr    *iattr)
555 {
556         return -xfs_setattr(XFS_I(dentry->d_inode), iattr, 0);
557 }
558
559 /*
560  * block_truncate_page can return an error, but we can't propagate it
561  * at all here. Leave a complaint + stack trace in the syslog because
562  * this could be bad. If it is bad, we need to propagate the error further.
563  */
564 STATIC void
565 xfs_vn_truncate(
566         struct inode    *inode)
567 {
568         int     error;
569         error = block_truncate_page(inode->i_mapping, inode->i_size,
570                                                         xfs_get_blocks);
571         WARN_ON(error);
572 }
573
574 STATIC long
575 xfs_vn_fallocate(
576         struct inode    *inode,
577         int             mode,
578         loff_t          offset,
579         loff_t          len)
580 {
581         long            error;
582         loff_t          new_size = 0;
583         xfs_flock64_t   bf;
584         xfs_inode_t     *ip = XFS_I(inode);
585
586         /* preallocation on directories not yet supported */
587         error = -ENODEV;
588         if (S_ISDIR(inode->i_mode))
589                 goto out_error;
590
591         bf.l_whence = 0;
592         bf.l_start = offset;
593         bf.l_len = len;
594
595         xfs_ilock(ip, XFS_IOLOCK_EXCL);
596         error = xfs_change_file_space(ip, XFS_IOC_RESVSP, &bf,
597                                       0, XFS_ATTR_NOLOCK);
598         if (!error && !(mode & FALLOC_FL_KEEP_SIZE) &&
599             offset + len > i_size_read(inode))
600                 new_size = offset + len;
601
602         /* Change file size if needed */
603         if (new_size) {
604                 struct iattr iattr;
605
606                 iattr.ia_valid = ATTR_SIZE;
607                 iattr.ia_size = new_size;
608                 error = xfs_setattr(ip, &iattr, XFS_ATTR_NOLOCK);
609         }
610
611         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
612 out_error:
613         return error;
614 }
615
616 #define XFS_FIEMAP_FLAGS        (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
617
618 /*
619  * Call fiemap helper to fill in user data.
620  * Returns positive errors to xfs_getbmap.
621  */
622 STATIC int
623 xfs_fiemap_format(
624         void                    **arg,
625         struct getbmapx         *bmv,
626         int                     *full)
627 {
628         int                     error;
629         struct fiemap_extent_info *fieinfo = *arg;
630         u32                     fiemap_flags = 0;
631         u64                     logical, physical, length;
632
633         /* Do nothing for a hole */
634         if (bmv->bmv_block == -1LL)
635                 return 0;
636
637         logical = BBTOB(bmv->bmv_offset);
638         physical = BBTOB(bmv->bmv_block);
639         length = BBTOB(bmv->bmv_length);
640
641         if (bmv->bmv_oflags & BMV_OF_PREALLOC)
642                 fiemap_flags |= FIEMAP_EXTENT_UNWRITTEN;
643         else if (bmv->bmv_oflags & BMV_OF_DELALLOC) {
644                 fiemap_flags |= FIEMAP_EXTENT_DELALLOC;
645                 physical = 0;   /* no block yet */
646         }
647         if (bmv->bmv_oflags & BMV_OF_LAST)
648                 fiemap_flags |= FIEMAP_EXTENT_LAST;
649
650         error = fiemap_fill_next_extent(fieinfo, logical, physical,
651                                         length, fiemap_flags);
652         if (error > 0) {
653                 error = 0;
654                 *full = 1;      /* user array now full */
655         }
656
657         return -error;
658 }
659
660 STATIC int
661 xfs_vn_fiemap(
662         struct inode            *inode,
663         struct fiemap_extent_info *fieinfo,
664         u64                     start,
665         u64                     length)
666 {
667         xfs_inode_t             *ip = XFS_I(inode);
668         struct getbmapx         bm;
669         int                     error;
670
671         error = fiemap_check_flags(fieinfo, XFS_FIEMAP_FLAGS);
672         if (error)
673                 return error;
674
675         /* Set up bmap header for xfs internal routine */
676         bm.bmv_offset = BTOBB(start);
677         /* Special case for whole file */
678         if (length == FIEMAP_MAX_OFFSET)
679                 bm.bmv_length = -1LL;
680         else
681                 bm.bmv_length = BTOBB(length);
682
683         /* our formatter will tell xfs_getbmap when to stop. */
684         bm.bmv_count = MAXEXTNUM;
685         bm.bmv_iflags = BMV_IF_PREALLOC;
686         if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR)
687                 bm.bmv_iflags |= BMV_IF_ATTRFORK;
688         if (!(fieinfo->fi_flags & FIEMAP_FLAG_SYNC))
689                 bm.bmv_iflags |= BMV_IF_DELALLOC;
690
691         error = xfs_getbmap(ip, &bm, xfs_fiemap_format, fieinfo);
692         if (error)
693                 return -error;
694
695         return 0;
696 }
697
698 static const struct inode_operations xfs_inode_operations = {
699         .permission             = xfs_vn_permission,
700         .truncate               = xfs_vn_truncate,
701         .getattr                = xfs_vn_getattr,
702         .setattr                = xfs_vn_setattr,
703         .setxattr               = generic_setxattr,
704         .getxattr               = generic_getxattr,
705         .removexattr            = generic_removexattr,
706         .listxattr              = xfs_vn_listxattr,
707         .fallocate              = xfs_vn_fallocate,
708         .fiemap                 = xfs_vn_fiemap,
709 };
710
711 static const struct inode_operations xfs_dir_inode_operations = {
712         .create                 = xfs_vn_create,
713         .lookup                 = xfs_vn_lookup,
714         .link                   = xfs_vn_link,
715         .unlink                 = xfs_vn_unlink,
716         .symlink                = xfs_vn_symlink,
717         .mkdir                  = xfs_vn_mkdir,
718         /*
719          * Yes, XFS uses the same method for rmdir and unlink.
720          *
721          * There are some subtile differences deeper in the code,
722          * but we use S_ISDIR to check for those.
723          */
724         .rmdir                  = xfs_vn_unlink,
725         .mknod                  = xfs_vn_mknod,
726         .rename                 = xfs_vn_rename,
727         .permission             = xfs_vn_permission,
728         .getattr                = xfs_vn_getattr,
729         .setattr                = xfs_vn_setattr,
730         .setxattr               = generic_setxattr,
731         .getxattr               = generic_getxattr,
732         .removexattr            = generic_removexattr,
733         .listxattr              = xfs_vn_listxattr,
734 };
735
736 static const struct inode_operations xfs_dir_ci_inode_operations = {
737         .create                 = xfs_vn_create,
738         .lookup                 = xfs_vn_ci_lookup,
739         .link                   = xfs_vn_link,
740         .unlink                 = xfs_vn_unlink,
741         .symlink                = xfs_vn_symlink,
742         .mkdir                  = xfs_vn_mkdir,
743         /*
744          * Yes, XFS uses the same method for rmdir and unlink.
745          *
746          * There are some subtile differences deeper in the code,
747          * but we use S_ISDIR to check for those.
748          */
749         .rmdir                  = xfs_vn_unlink,
750         .mknod                  = xfs_vn_mknod,
751         .rename                 = xfs_vn_rename,
752         .permission             = xfs_vn_permission,
753         .getattr                = xfs_vn_getattr,
754         .setattr                = xfs_vn_setattr,
755         .setxattr               = generic_setxattr,
756         .getxattr               = generic_getxattr,
757         .removexattr            = generic_removexattr,
758         .listxattr              = xfs_vn_listxattr,
759 };
760
761 static const struct inode_operations xfs_symlink_inode_operations = {
762         .readlink               = generic_readlink,
763         .follow_link            = xfs_vn_follow_link,
764         .put_link               = xfs_vn_put_link,
765         .permission             = xfs_vn_permission,
766         .getattr                = xfs_vn_getattr,
767         .setattr                = xfs_vn_setattr,
768         .setxattr               = generic_setxattr,
769         .getxattr               = generic_getxattr,
770         .removexattr            = generic_removexattr,
771         .listxattr              = xfs_vn_listxattr,
772 };
773
774 STATIC void
775 xfs_diflags_to_iflags(
776         struct inode            *inode,
777         struct xfs_inode        *ip)
778 {
779         if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
780                 inode->i_flags |= S_IMMUTABLE;
781         else
782                 inode->i_flags &= ~S_IMMUTABLE;
783         if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
784                 inode->i_flags |= S_APPEND;
785         else
786                 inode->i_flags &= ~S_APPEND;
787         if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
788                 inode->i_flags |= S_SYNC;
789         else
790                 inode->i_flags &= ~S_SYNC;
791         if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
792                 inode->i_flags |= S_NOATIME;
793         else
794                 inode->i_flags &= ~S_NOATIME;
795 }
796
797 /*
798  * Initialize the Linux inode, set up the operation vectors and
799  * unlock the inode.
800  *
801  * When reading existing inodes from disk this is called directly
802  * from xfs_iget, when creating a new inode it is called from
803  * xfs_ialloc after setting up the inode.
804  *
805  * We are always called with an uninitialised linux inode here.
806  * We need to initialise the necessary fields and take a reference
807  * on it.
808  */
809 void
810 xfs_setup_inode(
811         struct xfs_inode        *ip)
812 {
813         struct inode            *inode = &ip->i_vnode;
814
815         inode->i_ino = ip->i_ino;
816         inode->i_state = I_NEW|I_LOCK;
817         inode_add_to_lists(ip->i_mount->m_super, inode);
818
819         inode->i_mode   = ip->i_d.di_mode;
820         inode->i_nlink  = ip->i_d.di_nlink;
821         inode->i_uid    = ip->i_d.di_uid;
822         inode->i_gid    = ip->i_d.di_gid;
823
824         switch (inode->i_mode & S_IFMT) {
825         case S_IFBLK:
826         case S_IFCHR:
827                 inode->i_rdev =
828                         MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
829                               sysv_minor(ip->i_df.if_u2.if_rdev));
830                 break;
831         default:
832                 inode->i_rdev = 0;
833                 break;
834         }
835
836         inode->i_generation = ip->i_d.di_gen;
837         i_size_write(inode, ip->i_d.di_size);
838         inode->i_atime.tv_sec   = ip->i_d.di_atime.t_sec;
839         inode->i_atime.tv_nsec  = ip->i_d.di_atime.t_nsec;
840         inode->i_mtime.tv_sec   = ip->i_d.di_mtime.t_sec;
841         inode->i_mtime.tv_nsec  = ip->i_d.di_mtime.t_nsec;
842         inode->i_ctime.tv_sec   = ip->i_d.di_ctime.t_sec;
843         inode->i_ctime.tv_nsec  = ip->i_d.di_ctime.t_nsec;
844         xfs_diflags_to_iflags(inode, ip);
845
846         switch (inode->i_mode & S_IFMT) {
847         case S_IFREG:
848                 inode->i_op = &xfs_inode_operations;
849                 inode->i_fop = &xfs_file_operations;
850                 inode->i_mapping->a_ops = &xfs_address_space_operations;
851                 break;
852         case S_IFDIR:
853                 if (xfs_sb_version_hasasciici(&XFS_M(inode->i_sb)->m_sb))
854                         inode->i_op = &xfs_dir_ci_inode_operations;
855                 else
856                         inode->i_op = &xfs_dir_inode_operations;
857                 inode->i_fop = &xfs_dir_file_operations;
858                 break;
859         case S_IFLNK:
860                 inode->i_op = &xfs_symlink_inode_operations;
861                 if (!(ip->i_df.if_flags & XFS_IFINLINE))
862                         inode->i_mapping->a_ops = &xfs_address_space_operations;
863                 break;
864         default:
865                 inode->i_op = &xfs_inode_operations;
866                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
867                 break;
868         }
869
870         xfs_iflags_clear(ip, XFS_INEW);
871         barrier();
872
873         unlock_new_inode(inode);
874 }