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 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 = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
 557         if (!link) {
 558                 nd_set_link(nd, ERR_PTR(-ENOMEM));
 559                 return NULL;
 560         }
 561
 562         uio = 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         bhv_vattr_t     vattr = { .va_mask = XFS_AT_STAT };
 627         int             error;
 628
 629         error = bhv_vop_getattr(vp, &vattr, ATTR_LAZY, NULL);
 630         if (likely(!error)) {
 631                 stat->size = i_size_read(inode);
 632                 stat->dev = inode->i_sb->s_dev;
 633                 stat->rdev = (vattr.va_rdev == 0) ? 0 :
 634                                 MKDEV(sysv_major(vattr.va_rdev) & 0x1ff,
 635                                       sysv_minor(vattr.va_rdev));
 636                 stat->mode = vattr.va_mode;
 637                 stat->nlink = vattr.va_nlink;
 638                 stat->uid = vattr.va_uid;
 639                 stat->gid = vattr.va_gid;
 640                 stat->ino = vattr.va_nodeid;
 641                 stat->atime = vattr.va_atime;
 642                 stat->mtime = vattr.va_mtime;
 643                 stat->ctime = vattr.va_ctime;
 644                 stat->blocks = vattr.va_nblocks;
 645                 stat->blksize = vattr.va_blocksize;
 646         }
 647         return -error;
 648 }
 649
 650 STATIC int
 651 xfs_vn_setattr(
 652         struct dentry   *dentry,
 653         struct iattr    *attr)
 654 {
 655         struct inode    *inode = dentry->d_inode;
 656         unsigned int    ia_valid = attr->ia_valid;
 657         bhv_vnode_t     *vp = vn_from_inode(inode);
 658         bhv_vattr_t     vattr = { 0 };
 659         int             flags = 0;
 660         int             error;
 661
 662         if (ia_valid & ATTR_UID) {
 663                 vattr.va_mask |= XFS_AT_UID;
 664                 vattr.va_uid = attr->ia_uid;
 665         }
 666         if (ia_valid & ATTR_GID) {
 667                 vattr.va_mask |= XFS_AT_GID;
 668                 vattr.va_gid = attr->ia_gid;
 669         }
 670         if (ia_valid & ATTR_SIZE) {
 671                 vattr.va_mask |= XFS_AT_SIZE;
 672                 vattr.va_size = attr->ia_size;
 673         }
 674         if (ia_valid & ATTR_ATIME) {
 675                 vattr.va_mask |= XFS_AT_ATIME;
 676                 vattr.va_atime = attr->ia_atime;
 677                 inode->i_atime = attr->ia_atime;
 678         }
 679         if (ia_valid & ATTR_MTIME) {
 680                 vattr.va_mask |= XFS_AT_MTIME;
 681                 vattr.va_mtime = attr->ia_mtime;
 682         }
 683         if (ia_valid & ATTR_CTIME) {
 684                 vattr.va_mask |= XFS_AT_CTIME;
 685                 vattr.va_ctime = attr->ia_ctime;
 686         }
 687         if (ia_valid & ATTR_MODE) {
 688                 vattr.va_mask |= XFS_AT_MODE;
 689                 vattr.va_mode = attr->ia_mode;
 690                 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
 691                         inode->i_mode &= ~S_ISGID;
 692         }
 693
 694         if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET))
 695                 flags |= ATTR_UTIME;
 696 #ifdef ATTR_NO_BLOCK
 697         if ((ia_valid & ATTR_NO_BLOCK))
 698                 flags |= ATTR_NONBLOCK;
 699 #endif
 700
 701         error = bhv_vop_setattr(vp, &vattr, flags, NULL);
 702         if (likely(!error))
 703                 __vn_revalidate(vp, &vattr);
 704         return -error;
 705 }
 706
 707 STATIC void
 708 xfs_vn_truncate(
 709         struct inode    *inode)
 710 {
 711         block_truncate_page(inode->i_mapping, inode->i_size, xfs_get_blocks);
 712 }
 713
 714 STATIC int
 715 xfs_vn_setxattr(
 716         struct dentry   *dentry,
 717         const char      *name,
 718         const void      *data,
 719         size_t          size,
 720         int             flags)
 721 {
 722         bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
 723         char            *attr = (char *)name;
 724         attrnames_t     *namesp;
 725         int             xflags = 0;
 726         int             error;
 727
 728         namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
 729         if (!namesp)
 730                 return -EOPNOTSUPP;
 731         attr += namesp->attr_namelen;
 732         error = namesp->attr_capable(vp, NULL);
 733         if (error)
 734                 return error;
 735
 736         /* Convert Linux syscall to XFS internal ATTR flags */
 737         if (flags & XATTR_CREATE)
 738                 xflags |= ATTR_CREATE;
 739         if (flags & XATTR_REPLACE)
 740                 xflags |= ATTR_REPLACE;
 741         xflags |= namesp->attr_flag;
 742         return namesp->attr_set(vp, attr, (void *)data, size, xflags);
 743 }
 744
 745 STATIC ssize_t
 746 xfs_vn_getxattr(
 747         struct dentry   *dentry,
 748         const char      *name,
 749         void            *data,
 750         size_t          size)
 751 {
 752         bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
 753         char            *attr = (char *)name;
 754         attrnames_t     *namesp;
 755         int             xflags = 0;
 756         ssize_t         error;
 757
 758         namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
 759         if (!namesp)
 760                 return -EOPNOTSUPP;
 761         attr += namesp->attr_namelen;
 762         error = namesp->attr_capable(vp, NULL);
 763         if (error)
 764                 return error;
 765
 766         /* Convert Linux syscall to XFS internal ATTR flags */
 767         if (!size) {
 768                 xflags |= ATTR_KERNOVAL;
 769                 data = NULL;
 770         }
 771         xflags |= namesp->attr_flag;
 772         return namesp->attr_get(vp, attr, (void *)data, size, xflags);
 773 }
 774
 775 STATIC ssize_t
 776 xfs_vn_listxattr(
 777         struct dentry           *dentry,
 778         char                    *data,
 779         size_t                  size)
 780 {
 781         bhv_vnode_t             *vp = vn_from_inode(dentry->d_inode);
 782         int                     error, xflags = ATTR_KERNAMELS;
 783         ssize_t                 result;
 784
 785         if (!size)
 786                 xflags |= ATTR_KERNOVAL;
 787         xflags |= capable(CAP_SYS_ADMIN) ? ATTR_KERNFULLS : ATTR_KERNORMALS;
 788
 789         error = attr_generic_list(vp, data, size, xflags, &result);
 790         if (error < 0)
 791                 return error;
 792         return result;
 793 }
 794
 795 STATIC int
 796 xfs_vn_removexattr(
 797         struct dentry   *dentry,
 798         const char      *name)
 799 {
 800         bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
 801         char            *attr = (char *)name;
 802         attrnames_t     *namesp;
 803         int             xflags = 0;
 804         int             error;
 805
 806         namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
 807         if (!namesp)
 808                 return -EOPNOTSUPP;
 809         attr += namesp->attr_namelen;
 810         error = namesp->attr_capable(vp, NULL);
 811         if (error)
 812                 return error;
 813         xflags |= namesp->attr_flag;
 814         return namesp->attr_remove(vp, attr, xflags);
 815 }
 816
 817
 818 struct inode_operations xfs_inode_operations = {
 819         .permission             = xfs_vn_permission,
 820         .truncate               = xfs_vn_truncate,
 821         .getattr                = xfs_vn_getattr,
 822         .setattr                = xfs_vn_setattr,
 823         .setxattr               = xfs_vn_setxattr,
 824         .getxattr               = xfs_vn_getxattr,
 825         .listxattr              = xfs_vn_listxattr,
 826         .removexattr            = xfs_vn_removexattr,
 827 };
 828
 829 struct inode_operations xfs_dir_inode_operations = {
 830         .create                 = xfs_vn_create,
 831         .lookup                 = xfs_vn_lookup,
 832         .link                   = xfs_vn_link,
 833         .unlink                 = xfs_vn_unlink,
 834         .symlink                = xfs_vn_symlink,
 835         .mkdir                  = xfs_vn_mkdir,
 836         .rmdir                  = xfs_vn_rmdir,
 837         .mknod                  = xfs_vn_mknod,
 838         .rename                 = xfs_vn_rename,
 839         .permission             = xfs_vn_permission,
 840         .getattr                = xfs_vn_getattr,
 841         .setattr                = xfs_vn_setattr,
 842         .setxattr               = xfs_vn_setxattr,
 843         .getxattr               = xfs_vn_getxattr,
 844         .listxattr              = xfs_vn_listxattr,
 845         .removexattr            = xfs_vn_removexattr,
 846 };
 847
 848 struct inode_operations xfs_symlink_inode_operations = {
 849         .readlink               = generic_readlink,
 850         .follow_link            = xfs_vn_follow_link,
 851         .put_link               = xfs_vn_put_link,
 852         .permission             = xfs_vn_permission,
 853         .getattr                = xfs_vn_getattr,
 854         .setattr                = xfs_vn_setattr,
 855         .setxattr               = xfs_vn_setxattr,
 856         .getxattr               = xfs_vn_getxattr,
 857         .listxattr              = xfs_vn_listxattr,
 858         .removexattr            = xfs_vn_removexattr,
 859 };