git.oblomov.eu Git - linux-2.6/blob - 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_bit.h"
  21 #include "xfs_log.h"
  22 #include "xfs_inum.h"
  23 #include "xfs_trans.h"
  24 #include "xfs_sb.h"
  25 #include "xfs_ag.h"
  26 #include "xfs_dir2.h"
  27 #include "xfs_alloc.h"
  28 #include "xfs_dmapi.h"
  29 #include "xfs_quota.h"
  30 #include "xfs_mount.h"
  31 #include "xfs_bmap_btree.h"
  32 #include "xfs_alloc_btree.h"
  33 #include "xfs_ialloc_btree.h"
  34 #include "xfs_dir2_sf.h"
  35 #include "xfs_attr_sf.h"
  36 #include "xfs_dinode.h"
  37 #include "xfs_inode.h"
  38 #include "xfs_bmap.h"
  39 #include "xfs_btree.h"
  40 #include "xfs_ialloc.h"
  41 #include "xfs_rtalloc.h"
  42 #include "xfs_error.h"
  43 #include "xfs_itable.h"
  44 #include "xfs_rw.h"
  45 #include "xfs_acl.h"
  46 #include "xfs_cap.h"
  47 #include "xfs_mac.h"
  48 #include "xfs_attr.h"
  49 #include "xfs_buf_item.h"
  50 #include "xfs_utils.h"
  51
  52 #include <linux/capability.h>
  53 #include <linux/xattr.h>
  54 #include <linux/namei.h>
  55 #include <linux/security.h>
  56
  57 /*
  58  * Get a XFS inode from a given vnode.
  59  */
  60 xfs_inode_t *
  61 xfs_vtoi(
  62         bhv_vnode_t     *vp)
  63 {
  64         bhv_desc_t      *bdp;
  65
  66         bdp = bhv_lookup_range(VN_BHV_HEAD(vp),
  67                         VNODE_POSITION_XFS, VNODE_POSITION_XFS);
  68         if (unlikely(bdp == NULL))
  69                 return NULL;
  70         return XFS_BHVTOI(bdp);
  71 }
  72
  73 /*
  74  * Bring the atime in the XFS inode uptodate.
  75  * Used before logging the inode to disk or when the Linux inode goes away.
  76  */
  77 void
  78 xfs_synchronize_atime(
  79         xfs_inode_t     *ip)
  80 {
  81         bhv_vnode_t     *vp;
  82
  83         vp = XFS_ITOV_NULL(ip);
  84         if (vp) {
  85                 struct inode *inode = &vp->v_inode;
  86                 ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
  87                 ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
  88         }
  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  * NOTE -- callers MUST combine XFS_ICHGTIME_MOD or XFS_ICHGTIME_CHG
  97  *              with XFS_ICHGTIME_ACC to be sure that access time
  98  *              update will take.  Calling first with XFS_ICHGTIME_ACC
  99  *              and then XFS_ICHGTIME_MOD may fail to modify the access
 100  *              timestamp if the filesystem is mounted noacctm.
 101  */
 102 void
 103 xfs_ichgtime(
 104         xfs_inode_t     *ip,
 105         int             flags)
 106 {
 107         struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
 108         timespec_t      tv;
 109
 110         nanotime(&tv);
 111         if (flags & XFS_ICHGTIME_MOD) {
 112                 inode->i_mtime = tv;
 113                 ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
 114                 ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
 115         }
 116         if (flags & XFS_ICHGTIME_ACC) {
 117                 inode->i_atime = tv;
 118                 ip->i_d.di_atime.t_sec = (__int32_t)tv.tv_sec;
 119                 ip->i_d.di_atime.t_nsec = (__int32_t)tv.tv_nsec;
 120         }
 121         if (flags & XFS_ICHGTIME_CHG) {
 122                 inode->i_ctime = tv;
 123                 ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
 124                 ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
 125         }
 126
 127         /*
 128          * We update the i_update_core field _after_ changing
 129          * the timestamps in order to coordinate properly with
 130          * xfs_iflush() so that we don't lose timestamp updates.
 131          * This keeps us from having to hold the inode lock
 132          * while doing this.  We use the SYNCHRONIZE macro to
 133          * ensure that the compiler does not reorder the update
 134          * of i_update_core above the timestamp updates above.
 135          */
 136         SYNCHRONIZE();
 137         ip->i_update_core = 1;
 138         if (!(inode->i_state & I_LOCK))
 139                 mark_inode_dirty_sync(inode);
 140 }
 141
 142 /*
 143  * Variant on the above which avoids querying the system clock
 144  * in situations where we know the Linux inode timestamps have
 145  * just been updated (and so we can update our inode cheaply).
 146  */
 147 void
 148 xfs_ichgtime_fast(
 149         xfs_inode_t     *ip,
 150         struct inode    *inode,
 151         int             flags)
 152 {
 153         timespec_t      *tvp;
 154
 155         /*
 156          * Atime updates for read() & friends are handled lazily now, and
 157          * explicit updates must go through xfs_ichgtime()
 158          */
 159         ASSERT((flags & XFS_ICHGTIME_ACC) == 0);
 160
 161         /*
 162          * We're not supposed to change timestamps in readonly-mounted
 163          * filesystems.  Throw it away if anyone asks us.
 164          */
 165         if (unlikely(IS_RDONLY(inode)))
 166                 return;
 167
 168         if (flags & XFS_ICHGTIME_MOD) {
 169                 tvp = &inode->i_mtime;
 170                 ip->i_d.di_mtime.t_sec = (__int32_t)tvp->tv_sec;
 171                 ip->i_d.di_mtime.t_nsec = (__int32_t)tvp->tv_nsec;
 172         }
 173         if (flags & XFS_ICHGTIME_CHG) {
 174                 tvp = &inode->i_ctime;
 175                 ip->i_d.di_ctime.t_sec = (__int32_t)tvp->tv_sec;
 176                 ip->i_d.di_ctime.t_nsec = (__int32_t)tvp->tv_nsec;
 177         }
 178
 179         /*
 180          * We update the i_update_core field _after_ changing
 181          * the timestamps in order to coordinate properly with
 182          * xfs_iflush() so that we don't lose timestamp updates.
 183          * This keeps us from having to hold the inode lock
 184          * while doing this.  We use the SYNCHRONIZE macro to
 185          * ensure that the compiler does not reorder the update
 186          * of i_update_core above the timestamp updates above.
 187          */
 188         SYNCHRONIZE();
 189         ip->i_update_core = 1;
 190         if (!(inode->i_state & I_LOCK))
 191                 mark_inode_dirty_sync(inode);
 192 }
 193
 194
 195 /*
 196  * Pull the link count and size up from the xfs inode to the linux inode
 197  */
 198 STATIC void
 199 xfs_validate_fields(
 200         struct inode    *ip,
 201         bhv_vattr_t     *vattr)
 202 {
 203         vattr->va_mask = XFS_AT_NLINK|XFS_AT_SIZE|XFS_AT_NBLOCKS;
 204         if (!bhv_vop_getattr(vn_from_inode(ip), vattr, ATTR_LAZY, NULL)) {
 205                 ip->i_nlink = vattr->va_nlink;
 206                 ip->i_blocks = vattr->va_nblocks;
 207
 208                 /* we're under i_sem so i_size can't change under us */
 209                 if (i_size_read(ip) != vattr->va_size)
 210                         i_size_write(ip, vattr->va_size);
 211         }
 212 }
 213
 214 /*
 215  * Hook in SELinux.  This is not quite correct yet, what we really need
 216  * here (as we do for default ACLs) is a mechanism by which creation of
 217  * these attrs can be journalled at inode creation time (along with the
 218  * inode, of course, such that log replay can't cause these to be lost).
 219  */
 220 STATIC int
 221 xfs_init_security(
 222         bhv_vnode_t     *vp,
 223         struct inode    *dir)
 224 {
 225         struct inode    *ip = vn_to_inode(vp);
 226         size_t          length;
 227         void            *value;
 228         char            *name;
 229         int             error;
 230
 231         error = security_inode_init_security(ip, dir, &name, &value, &length);
 232         if (error) {
 233                 if (error == -EOPNOTSUPP)
 234                         return 0;
 235                 return -error;
 236         }
 237
 238         error = bhv_vop_attr_set(vp, name, value, length, ATTR_SECURE, NULL);
 239         if (!error)
 240                 VMODIFY(vp);
 241
 242         kfree(name);
 243         kfree(value);
 244         return error;
 245 }
 246
 247 /*
 248  * Determine whether a process has a valid fs_struct (kernel daemons
 249  * like knfsd don't have an fs_struct).
 250  *
 251  * XXX(hch):  nfsd is broken, better fix it instead.
 252  */
 253 STATIC inline int
 254 xfs_has_fs_struct(struct task_struct *task)
 255 {
 256         return (task->fs != init_task.fs);
 257 }
 258
 259 STATIC inline void
 260 xfs_cleanup_inode(
 261         bhv_vnode_t     *dvp,
 262         bhv_vnode_t     *vp,
 263         struct dentry   *dentry,
 264         int             mode)
 265 {
 266         struct dentry   teardown = {};
 267
 268         /* Oh, the horror.
 269          * If we can't add the ACL or we fail in
 270          * xfs_init_security we must back out.
 271          * ENOSPC can hit here, among other things.
 272          */
 273         teardown.d_inode = vn_to_inode(vp);
 274         teardown.d_name = dentry->d_name;
 275
 276         if (S_ISDIR(mode))
 277                 bhv_vop_rmdir(dvp, &teardown, NULL);
 278         else
 279                 bhv_vop_remove(dvp, &teardown, NULL);
 280         VN_RELE(vp);
 281 }
 282
 283 STATIC int
 284 xfs_vn_mknod(
 285         struct inode    *dir,
 286         struct dentry   *dentry,
 287         int             mode,
 288         dev_t           rdev)
 289 {
 290         struct inode    *ip;
 291         bhv_vattr_t     vattr = { 0 };
 292         bhv_vnode_t     *vp = NULL, *dvp = vn_from_inode(dir);
 293         xfs_acl_t       *default_acl = NULL;
 294         attrexists_t    test_default_acl = _ACL_DEFAULT_EXISTS;
 295         int             error;
 296
 297         /*
 298          * Irix uses Missed'em'V split, but doesn't want to see
 299          * the upper 5 bits of (14bit) major.
 300          */
 301         if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
 302                 return -EINVAL;
 303
 304         if (unlikely(test_default_acl && test_default_acl(dvp))) {
 305                 if (!_ACL_ALLOC(default_acl)) {
 306                         return -ENOMEM;
 307                 }
 308                 if (!_ACL_GET_DEFAULT(dvp, default_acl)) {
 309                         _ACL_FREE(default_acl);
 310                         default_acl = NULL;
 311                 }
 312         }
 313
 314         if (IS_POSIXACL(dir) && !default_acl && xfs_has_fs_struct(current))
 315                 mode &= ~current->fs->umask;
 316
 317         vattr.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
 318         vattr.va_mode = mode;
 319
 320         switch (mode & S_IFMT) {
 321         case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK:
 322                 vattr.va_rdev = sysv_encode_dev(rdev);
 323                 vattr.va_mask |= XFS_AT_RDEV;
 324                 /*FALLTHROUGH*/
 325         case S_IFREG:
 326                 error = bhv_vop_create(dvp, dentry, &vattr, &vp, NULL);
 327                 break;
 328         case S_IFDIR:
 329                 error = bhv_vop_mkdir(dvp, dentry, &vattr, &vp, NULL);
 330                 break;
 331         default:
 332                 error = EINVAL;
 333                 break;
 334         }
 335
 336         if (unlikely(!error)) {
 337                 error = xfs_init_security(vp, dir);
 338                 if (error)
 339                         xfs_cleanup_inode(dvp, vp, dentry, mode);
 340         }
 341
 342         if (unlikely(default_acl)) {
 343                 if (!error) {
 344                         error = _ACL_INHERIT(vp, &vattr, default_acl);
 345                         if (!error)
 346                                 VMODIFY(vp);
 347                         else
 348                                 xfs_cleanup_inode(dvp, vp, dentry, mode);
 349                 }
 350                 _ACL_FREE(default_acl);
 351         }
 352
 353         if (likely(!error)) {
 354                 ASSERT(vp);
 355                 ip = vn_to_inode(vp);
 356
 357                 if (S_ISCHR(mode) || S_ISBLK(mode))
 358                         ip->i_rdev = rdev;
 359                 else if (S_ISDIR(mode))
 360                         xfs_validate_fields(ip, &vattr);
 361                 d_instantiate(dentry, ip);
 362                 xfs_validate_fields(dir, &vattr);
 363         }
 364         return -error;
 365 }
 366
 367 STATIC int
 368 xfs_vn_create(
 369         struct inode    *dir,
 370         struct dentry   *dentry,
 371         int             mode,
 372         struct nameidata *nd)
 373 {
 374         return xfs_vn_mknod(dir, dentry, mode, 0);
 375 }
 376
 377 STATIC int
 378 xfs_vn_mkdir(
 379         struct inode    *dir,
 380         struct dentry   *dentry,
 381         int             mode)
 382 {
 383         return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
 384 }
 385
 386 STATIC struct dentry *
 387 xfs_vn_lookup(
 388         struct inode    *dir,
 389         struct dentry   *dentry,
 390         struct nameidata *nd)
 391 {
 392         bhv_vnode_t     *vp = vn_from_inode(dir), *cvp;
 393         int             error;
 394
 395         if (dentry->d_name.len >= MAXNAMELEN)
 396                 return ERR_PTR(-ENAMETOOLONG);
 397
 398         error = bhv_vop_lookup(vp, dentry, &cvp, 0, NULL, NULL);
 399         if (unlikely(error)) {
 400                 if (unlikely(error != ENOENT))
 401                         return ERR_PTR(-error);
 402                 d_add(dentry, NULL);
 403                 return NULL;
 404         }
 405
 406         return d_splice_alias(vn_to_inode(cvp), dentry);
 407 }
 408
 409 STATIC int
 410 xfs_vn_link(
 411         struct dentry   *old_dentry,
 412         struct inode    *dir,
 413         struct dentry   *dentry)
 414 {
 415         struct inode    *ip;    /* inode of guy being linked to */
 416         bhv_vnode_t     *tdvp;  /* target directory for new name/link */
 417         bhv_vnode_t     *vp;    /* vp of name being linked */
 418         bhv_vattr_t     vattr;
 419         int             error;
 420
 421         ip = old_dentry->d_inode;       /* inode being linked to */
 422         tdvp = vn_from_inode(dir);
 423         vp = vn_from_inode(ip);
 424
 425         VN_HOLD(vp);
 426         error = bhv_vop_link(tdvp, vp, dentry, NULL);
 427         if (unlikely(error)) {
 428                 VN_RELE(vp);
 429         } else {
 430                 VMODIFY(tdvp);
 431                 xfs_validate_fields(ip, &vattr);
 432                 d_instantiate(dentry, ip);
 433         }
 434         return -error;
 435 }
 436
 437 STATIC int
 438 xfs_vn_unlink(
 439         struct inode    *dir,
 440         struct dentry   *dentry)
 441 {
 442         struct inode    *inode;
 443         bhv_vnode_t     *dvp;   /* directory containing name to remove */
 444         bhv_vattr_t     vattr;
 445         int             error;
 446
 447         inode = dentry->d_inode;
 448         dvp = vn_from_inode(dir);
 449
 450         error = bhv_vop_remove(dvp, dentry, NULL);
 451         if (likely(!error)) {
 452                 xfs_validate_fields(dir, &vattr);       /* size needs update */
 453                 xfs_validate_fields(inode, &vattr);
 454         }
 455         return -error;
 456 }
 457
 458 STATIC int
 459 xfs_vn_symlink(
 460         struct inode    *dir,
 461         struct dentry   *dentry,
 462         const char      *symname)
 463 {
 464         struct inode    *ip;
 465         bhv_vattr_t     va = { 0 };
 466         bhv_vnode_t     *dvp;   /* directory containing name of symlink */
 467         bhv_vnode_t     *cvp;   /* used to lookup symlink to put in dentry */
 468         int             error;
 469
 470         dvp = vn_from_inode(dir);
 471         cvp = NULL;
 472
 473         va.va_mode = S_IFLNK |
 474                 (irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO);
 475         va.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
 476
 477         error = bhv_vop_symlink(dvp, dentry, &va, (char *)symname, &cvp, NULL);
 478         if (likely(!error && cvp)) {
 479                 error = xfs_init_security(cvp, dir);
 480                 if (likely(!error)) {
 481                         ip = vn_to_inode(cvp);
 482                         d_instantiate(dentry, ip);
 483                         xfs_validate_fields(dir, &va);
 484                         xfs_validate_fields(ip, &va);
 485                 } else {
 486                         xfs_cleanup_inode(dvp, cvp, dentry, 0);
 487                 }
 488         }
 489         return -error;
 490 }
 491
 492 STATIC int
 493 xfs_vn_rmdir(
 494         struct inode    *dir,
 495         struct dentry   *dentry)
 496 {
 497         struct inode    *inode = dentry->d_inode;
 498         bhv_vnode_t     *dvp = vn_from_inode(dir);
 499         bhv_vattr_t     vattr;
 500         int             error;
 501
 502         error = bhv_vop_rmdir(dvp, dentry, NULL);
 503         if (likely(!error)) {
 504                 xfs_validate_fields(inode, &vattr);
 505                 xfs_validate_fields(dir, &vattr);
 506         }
 507         return -error;
 508 }
 509
 510 STATIC int
 511 xfs_vn_rename(
 512         struct inode    *odir,
 513         struct dentry   *odentry,
 514         struct inode    *ndir,
 515         struct dentry   *ndentry)
 516 {
 517         struct inode    *new_inode = ndentry->d_inode;
 518         bhv_vnode_t     *fvp;   /* from directory */
 519         bhv_vnode_t     *tvp;   /* target directory */
 520         bhv_vattr_t     vattr;
 521         int             error;
 522
 523         fvp = vn_from_inode(odir);
 524         tvp = vn_from_inode(ndir);
 525
 526         error = bhv_vop_rename(fvp, odentry, tvp, ndentry, NULL);
 527         if (likely(!error)) {
 528                 if (new_inode)
 529                         xfs_validate_fields(new_inode, &vattr);
 530                 xfs_validate_fields(odir, &vattr);
 531                 if (ndir != odir)
 532                         xfs_validate_fields(ndir, &vattr);
 533         }
 534         return -error;
 535 }
 536
 537 /*
 538  * careful here - this function can get called recursively, so
 539  * we need to be very careful about how much stack we use.
 540  * uio is kmalloced for this reason...
 541  */
 542 STATIC void *
 543 xfs_vn_follow_link(
 544         struct dentry           *dentry,
 545         struct nameidata        *nd)
 546 {
 547         bhv_vnode_t             *vp;
 548         uio_t                   *uio;
 549         iovec_t                 iov;
 550         int                     error;
 551         char                    *link;
 552
 553         ASSERT(dentry);
 554         ASSERT(nd);
 555
 556         link = (char *)kmalloc(MAXPATHLEN+1, GFP_KERNEL);
 557         if (!link) {
 558                 nd_set_link(nd, ERR_PTR(-ENOMEM));
 559                 return NULL;
 560         }
 561
 562         uio = (uio_t *)kmalloc(sizeof(uio_t), GFP_KERNEL);
 563         if (!uio) {
 564                 kfree(link);
 565                 nd_set_link(nd, ERR_PTR(-ENOMEM));
 566                 return NULL;
 567         }
 568
 569         vp = vn_from_inode(dentry->d_inode);
 570
 571         iov.iov_base = link;
 572         iov.iov_len = MAXPATHLEN;
 573
 574         uio->uio_iov = &iov;
 575         uio->uio_offset = 0;
 576         uio->uio_segflg = UIO_SYSSPACE;
 577         uio->uio_resid = MAXPATHLEN;
 578         uio->uio_iovcnt = 1;
 579
 580         error = bhv_vop_readlink(vp, uio, 0, NULL);
 581         if (unlikely(error)) {
 582                 kfree(link);
 583                 link = ERR_PTR(-error);
 584         } else {
 585                 link[MAXPATHLEN - uio->uio_resid] = '\0';
 586         }
 587         kfree(uio);
 588
 589         nd_set_link(nd, link);
 590         return NULL;
 591 }
 592
 593 STATIC void
 594 xfs_vn_put_link(
 595         struct dentry   *dentry,
 596         struct nameidata *nd,
 597         void            *p)
 598 {
 599         char            *s = nd_get_link(nd);
 600
 601         if (!IS_ERR(s))
 602                 kfree(s);
 603 }
 604
 605 #ifdef CONFIG_XFS_POSIX_ACL
 606 STATIC int
 607 xfs_vn_permission(
 608         struct inode    *inode,
 609         int             mode,
 610         struct nameidata *nd)
 611 {
 612         return -bhv_vop_access(vn_from_inode(inode), mode << 6, NULL);
 613 }
 614 #else
 615 #define xfs_vn_permission NULL
 616 #endif
 617
 618 STATIC int
 619 xfs_vn_getattr(
 620         struct vfsmount *mnt,
 621         struct dentry   *dentry,
 622         struct kstat    *stat)
 623 {
 624         struct inode    *inode = dentry->d_inode;
 625         bhv_vnode_t     *vp = vn_from_inode(inode);
 626         int             error = 0;
 627
 628         if (unlikely(vp->v_flag & VMODIFIED))
 629                 error = vn_revalidate(vp);
 630         if (!error)
 631                 generic_fillattr(inode, stat);
 632         return -error;
 633 }
 634
 635 STATIC int
 636 xfs_vn_setattr(
 637         struct dentry   *dentry,
 638         struct iattr    *attr)
 639 {
 640         struct inode    *inode = dentry->d_inode;
 641         unsigned int    ia_valid = attr->ia_valid;
 642         bhv_vnode_t     *vp = vn_from_inode(inode);
 643         bhv_vattr_t     vattr = { 0 };
 644         int             flags = 0;
 645         int             error;
 646
 647         if (ia_valid & ATTR_UID) {
 648                 vattr.va_mask |= XFS_AT_UID;
 649                 vattr.va_uid = attr->ia_uid;
 650         }
 651         if (ia_valid & ATTR_GID) {
 652                 vattr.va_mask |= XFS_AT_GID;
 653                 vattr.va_gid = attr->ia_gid;
 654         }
 655         if (ia_valid & ATTR_SIZE) {
 656                 vattr.va_mask |= XFS_AT_SIZE;
 657                 vattr.va_size = attr->ia_size;
 658         }
 659         if (ia_valid & ATTR_ATIME) {
 660                 vattr.va_mask |= XFS_AT_ATIME;
 661                 vattr.va_atime = attr->ia_atime;
 662                 inode->i_atime = attr->ia_atime;
 663         }
 664         if (ia_valid & ATTR_MTIME) {
 665                 vattr.va_mask |= XFS_AT_MTIME;
 666                 vattr.va_mtime = attr->ia_mtime;
 667         }
 668         if (ia_valid & ATTR_CTIME) {
 669                 vattr.va_mask |= XFS_AT_CTIME;
 670                 vattr.va_ctime = attr->ia_ctime;
 671         }
 672         if (ia_valid & ATTR_MODE) {
 673                 vattr.va_mask |= XFS_AT_MODE;
 674                 vattr.va_mode = attr->ia_mode;
 675                 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
 676                         inode->i_mode &= ~S_ISGID;
 677         }
 678
 679         if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET))
 680                 flags |= ATTR_UTIME;
 681 #ifdef ATTR_NO_BLOCK
 682         if ((ia_valid & ATTR_NO_BLOCK))
 683                 flags |= ATTR_NONBLOCK;
 684 #endif
 685
 686         error = bhv_vop_setattr(vp, &vattr, flags, NULL);
 687         if (likely(!error))
 688                 __vn_revalidate(vp, &vattr);
 689         return -error;
 690 }
 691
 692 STATIC void
 693 xfs_vn_truncate(
 694         struct inode    *inode)
 695 {
 696         block_truncate_page(inode->i_mapping, inode->i_size, xfs_get_blocks);
 697 }
 698
 699 STATIC int
 700 xfs_vn_setxattr(
 701         struct dentry   *dentry,
 702         const char      *name,
 703         const void      *data,
 704         size_t          size,
 705         int             flags)
 706 {
 707         bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
 708         char            *attr = (char *)name;
 709         attrnames_t     *namesp;
 710         int             xflags = 0;
 711         int             error;
 712
 713         namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
 714         if (!namesp)
 715                 return -EOPNOTSUPP;
 716         attr += namesp->attr_namelen;
 717         error = namesp->attr_capable(vp, NULL);
 718         if (error)
 719                 return error;
 720
 721         /* Convert Linux syscall to XFS internal ATTR flags */
 722         if (flags & XATTR_CREATE)
 723                 xflags |= ATTR_CREATE;
 724         if (flags & XATTR_REPLACE)
 725                 xflags |= ATTR_REPLACE;
 726         xflags |= namesp->attr_flag;
 727         return namesp->attr_set(vp, attr, (void *)data, size, xflags);
 728 }
 729
 730 STATIC ssize_t
 731 xfs_vn_getxattr(
 732         struct dentry   *dentry,
 733         const char      *name,
 734         void            *data,
 735         size_t          size)
 736 {
 737         bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
 738         char            *attr = (char *)name;
 739         attrnames_t     *namesp;
 740         int             xflags = 0;
 741         ssize_t         error;
 742
 743         namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
 744         if (!namesp)
 745                 return -EOPNOTSUPP;
 746         attr += namesp->attr_namelen;
 747         error = namesp->attr_capable(vp, NULL);
 748         if (error)
 749                 return error;
 750
 751         /* Convert Linux syscall to XFS internal ATTR flags */
 752         if (!size) {
 753                 xflags |= ATTR_KERNOVAL;
 754                 data = NULL;
 755         }
 756         xflags |= namesp->attr_flag;
 757         return namesp->attr_get(vp, attr, (void *)data, size, xflags);
 758 }
 759
 760 STATIC ssize_t
 761 xfs_vn_listxattr(
 762         struct dentry           *dentry,
 763         char                    *data,
 764         size_t                  size)
 765 {
 766         bhv_vnode_t             *vp = vn_from_inode(dentry->d_inode);
 767         int                     error, xflags = ATTR_KERNAMELS;
 768         ssize_t                 result;
 769
 770         if (!size)
 771                 xflags |= ATTR_KERNOVAL;
 772         xflags |= capable(CAP_SYS_ADMIN) ? ATTR_KERNFULLS : ATTR_KERNORMALS;
 773
 774         error = attr_generic_list(vp, data, size, xflags, &result);
 775         if (error < 0)
 776                 return error;
 777         return result;
 778 }
 779
 780 STATIC int
 781 xfs_vn_removexattr(
 782         struct dentry   *dentry,
 783         const char      *name)
 784 {
 785         bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
 786         char            *attr = (char *)name;
 787         attrnames_t     *namesp;
 788         int             xflags = 0;
 789         int             error;
 790
 791         namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
 792         if (!namesp)
 793                 return -EOPNOTSUPP;
 794         attr += namesp->attr_namelen;
 795         error = namesp->attr_capable(vp, NULL);
 796         if (error)
 797                 return error;
 798         xflags |= namesp->attr_flag;
 799         return namesp->attr_remove(vp, attr, xflags);
 800 }
 801
 802
 803 struct inode_operations xfs_inode_operations = {
 804         .permission             = xfs_vn_permission,
 805         .truncate               = xfs_vn_truncate,
 806         .getattr                = xfs_vn_getattr,
 807         .setattr                = xfs_vn_setattr,
 808         .setxattr               = xfs_vn_setxattr,
 809         .getxattr               = xfs_vn_getxattr,
 810         .listxattr              = xfs_vn_listxattr,
 811         .removexattr            = xfs_vn_removexattr,
 812 };
 813
 814 struct inode_operations xfs_dir_inode_operations = {
 815         .create                 = xfs_vn_create,
 816         .lookup                 = xfs_vn_lookup,
 817         .link                   = xfs_vn_link,
 818         .unlink                 = xfs_vn_unlink,
 819         .symlink                = xfs_vn_symlink,
 820         .mkdir                  = xfs_vn_mkdir,
 821         .rmdir                  = xfs_vn_rmdir,
 822         .mknod                  = xfs_vn_mknod,
 823         .rename                 = xfs_vn_rename,
 824         .permission             = xfs_vn_permission,
 825         .getattr                = xfs_vn_getattr,
 826         .setattr                = xfs_vn_setattr,
 827         .setxattr               = xfs_vn_setxattr,
 828         .getxattr               = xfs_vn_getxattr,
 829         .listxattr              = xfs_vn_listxattr,
 830         .removexattr            = xfs_vn_removexattr,
 831 };
 832
 833 struct inode_operations xfs_symlink_inode_operations = {
 834         .readlink               = generic_readlink,
 835         .follow_link            = xfs_vn_follow_link,
 836         .put_link               = xfs_vn_put_link,
 837         .permission             = xfs_vn_permission,
 838         .getattr                = xfs_vn_getattr,
 839         .setattr                = xfs_vn_setattr,
 840         .setxattr               = xfs_vn_setxattr,
 841         .getxattr               = xfs_vn_getxattr,
 842         .listxattr              = xfs_vn_listxattr,
 843         .removexattr            = xfs_vn_removexattr,
 844 };