aboutsummaryrefslogtreecommitdiffstats
path: root/fs/xfs/linux-2.6/xfs_iops.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/xfs/linux-2.6/xfs_iops.c')
-rw-r--r--fs/xfs/linux-2.6/xfs_iops.c1210
1 files changed, 0 insertions, 1210 deletions
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
deleted file mode 100644
index b9c172b3fbbe..000000000000
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ /dev/null
@@ -1,1210 +0,0 @@
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_alloc.h"
28#include "xfs_quota.h"
29#include "xfs_mount.h"
30#include "xfs_bmap_btree.h"
31#include "xfs_dinode.h"
32#include "xfs_inode.h"
33#include "xfs_bmap.h"
34#include "xfs_rtalloc.h"
35#include "xfs_error.h"
36#include "xfs_itable.h"
37#include "xfs_rw.h"
38#include "xfs_attr.h"
39#include "xfs_buf_item.h"
40#include "xfs_utils.h"
41#include "xfs_vnodeops.h"
42#include "xfs_inode_item.h"
43#include "xfs_trace.h"
44
45#include <linux/capability.h>
46#include <linux/xattr.h>
47#include <linux/namei.h>
48#include <linux/posix_acl.h>
49#include <linux/security.h>
50#include <linux/fiemap.h>
51#include <linux/slab.h>
52
53/*
54 * Bring the timestamps in the XFS inode uptodate.
55 *
56 * Used before writing the inode to disk.
57 */
58void
59xfs_synchronize_times(
60 xfs_inode_t *ip)
61{
62 struct inode *inode = VFS_I(ip);
63
64 ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
65 ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
66 ip->i_d.di_ctime.t_sec = (__int32_t)inode->i_ctime.tv_sec;
67 ip->i_d.di_ctime.t_nsec = (__int32_t)inode->i_ctime.tv_nsec;
68 ip->i_d.di_mtime.t_sec = (__int32_t)inode->i_mtime.tv_sec;
69 ip->i_d.di_mtime.t_nsec = (__int32_t)inode->i_mtime.tv_nsec;
70}
71
72/*
73 * If the linux inode is valid, mark it dirty.
74 * Used when committing a dirty inode into a transaction so that
75 * the inode will get written back by the linux code
76 */
77void
78xfs_mark_inode_dirty_sync(
79 xfs_inode_t *ip)
80{
81 struct inode *inode = VFS_I(ip);
82
83 if (!(inode->i_state & (I_WILL_FREE|I_FREEING)))
84 mark_inode_dirty_sync(inode);
85}
86
87void
88xfs_mark_inode_dirty(
89 xfs_inode_t *ip)
90{
91 struct inode *inode = VFS_I(ip);
92
93 if (!(inode->i_state & (I_WILL_FREE|I_FREEING)))
94 mark_inode_dirty(inode);
95}
96
97/*
98 * Hook in SELinux. This is not quite correct yet, what we really need
99 * here (as we do for default ACLs) is a mechanism by which creation of
100 * these attrs can be journalled at inode creation time (along with the
101 * inode, of course, such that log replay can't cause these to be lost).
102 */
103STATIC int
104xfs_init_security(
105 struct inode *inode,
106 struct inode *dir,
107 const struct qstr *qstr)
108{
109 struct xfs_inode *ip = XFS_I(inode);
110 size_t length;
111 void *value;
112 unsigned char *name;
113 int error;
114
115 error = security_inode_init_security(inode, dir, qstr, (char **)&name,
116 &value, &length);
117 if (error) {
118 if (error == -EOPNOTSUPP)
119 return 0;
120 return -error;
121 }
122
123 error = xfs_attr_set(ip, name, value, length, ATTR_SECURE);
124
125 kfree(name);
126 kfree(value);
127 return error;
128}
129
130static void
131xfs_dentry_to_name(
132 struct xfs_name *namep,
133 struct dentry *dentry)
134{
135 namep->name = dentry->d_name.name;
136 namep->len = dentry->d_name.len;
137}
138
139STATIC void
140xfs_cleanup_inode(
141 struct inode *dir,
142 struct inode *inode,
143 struct dentry *dentry)
144{
145 struct xfs_name teardown;
146
147 /* Oh, the horror.
148 * If we can't add the ACL or we fail in
149 * xfs_init_security we must back out.
150 * ENOSPC can hit here, among other things.
151 */
152 xfs_dentry_to_name(&teardown, dentry);
153
154 xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
155 iput(inode);
156}
157
158STATIC int
159xfs_vn_mknod(
160 struct inode *dir,
161 struct dentry *dentry,
162 int mode,
163 dev_t rdev)
164{
165 struct inode *inode;
166 struct xfs_inode *ip = NULL;
167 struct posix_acl *default_acl = NULL;
168 struct xfs_name name;
169 int error;
170
171 /*
172 * Irix uses Missed'em'V split, but doesn't want to see
173 * the upper 5 bits of (14bit) major.
174 */
175 if (S_ISCHR(mode) || S_ISBLK(mode)) {
176 if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
177 return -EINVAL;
178 rdev = sysv_encode_dev(rdev);
179 } else {
180 rdev = 0;
181 }
182
183 if (IS_POSIXACL(dir)) {
184 default_acl = xfs_get_acl(dir, ACL_TYPE_DEFAULT);
185 if (IS_ERR(default_acl))
186 return PTR_ERR(default_acl);
187
188 if (!default_acl)
189 mode &= ~current_umask();
190 }
191
192 xfs_dentry_to_name(&name, dentry);
193 error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip);
194 if (unlikely(error))
195 goto out_free_acl;
196
197 inode = VFS_I(ip);
198
199 error = xfs_init_security(inode, dir, &dentry->d_name);
200 if (unlikely(error))
201 goto out_cleanup_inode;
202
203 if (default_acl) {
204 error = -xfs_inherit_acl(inode, default_acl);
205 default_acl = NULL;
206 if (unlikely(error))
207 goto out_cleanup_inode;
208 }
209
210
211 d_instantiate(dentry, inode);
212 return -error;
213
214 out_cleanup_inode:
215 xfs_cleanup_inode(dir, inode, dentry);
216 out_free_acl:
217 posix_acl_release(default_acl);
218 return -error;
219}
220
221STATIC int
222xfs_vn_create(
223 struct inode *dir,
224 struct dentry *dentry,
225 int mode,
226 struct nameidata *nd)
227{
228 return xfs_vn_mknod(dir, dentry, mode, 0);
229}
230
231STATIC int
232xfs_vn_mkdir(
233 struct inode *dir,
234 struct dentry *dentry,
235 int mode)
236{
237 return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
238}
239
240STATIC struct dentry *
241xfs_vn_lookup(
242 struct inode *dir,
243 struct dentry *dentry,
244 struct nameidata *nd)
245{
246 struct xfs_inode *cip;
247 struct xfs_name name;
248 int error;
249
250 if (dentry->d_name.len >= MAXNAMELEN)
251 return ERR_PTR(-ENAMETOOLONG);
252
253 xfs_dentry_to_name(&name, dentry);
254 error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
255 if (unlikely(error)) {
256 if (unlikely(error != ENOENT))
257 return ERR_PTR(-error);
258 d_add(dentry, NULL);
259 return NULL;
260 }
261
262 return d_splice_alias(VFS_I(cip), dentry);
263}
264
265STATIC struct dentry *
266xfs_vn_ci_lookup(
267 struct inode *dir,
268 struct dentry *dentry,
269 struct nameidata *nd)
270{
271 struct xfs_inode *ip;
272 struct xfs_name xname;
273 struct xfs_name ci_name;
274 struct qstr dname;
275 int error;
276
277 if (dentry->d_name.len >= MAXNAMELEN)
278 return ERR_PTR(-ENAMETOOLONG);
279
280 xfs_dentry_to_name(&xname, dentry);
281 error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
282 if (unlikely(error)) {
283 if (unlikely(error != ENOENT))
284 return ERR_PTR(-error);
285 /*
286 * call d_add(dentry, NULL) here when d_drop_negative_children
287 * is called in xfs_vn_mknod (ie. allow negative dentries
288 * with CI filesystems).
289 */
290 return NULL;
291 }
292
293 /* if exact match, just splice and exit */
294 if (!ci_name.name)
295 return d_splice_alias(VFS_I(ip), dentry);
296
297 /* else case-insensitive match... */
298 dname.name = ci_name.name;
299 dname.len = ci_name.len;
300 dentry = d_add_ci(dentry, VFS_I(ip), &dname);
301 kmem_free(ci_name.name);
302 return dentry;
303}
304
305STATIC int
306xfs_vn_link(
307 struct dentry *old_dentry,
308 struct inode *dir,
309 struct dentry *dentry)
310{
311 struct inode *inode = old_dentry->d_inode;
312 struct xfs_name name;
313 int error;
314
315 xfs_dentry_to_name(&name, dentry);
316
317 error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
318 if (unlikely(error))
319 return -error;
320
321 ihold(inode);
322 d_instantiate(dentry, inode);
323 return 0;
324}
325
326STATIC int
327xfs_vn_unlink(
328 struct inode *dir,
329 struct dentry *dentry)
330{
331 struct xfs_name name;
332 int error;
333
334 xfs_dentry_to_name(&name, dentry);
335
336 error = -xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
337 if (error)
338 return error;
339
340 /*
341 * With unlink, the VFS makes the dentry "negative": no inode,
342 * but still hashed. This is incompatible with case-insensitive
343 * mode, so invalidate (unhash) the dentry in CI-mode.
344 */
345 if (xfs_sb_version_hasasciici(&XFS_M(dir->i_sb)->m_sb))
346 d_invalidate(dentry);
347 return 0;
348}
349
350STATIC int
351xfs_vn_symlink(
352 struct inode *dir,
353 struct dentry *dentry,
354 const char *symname)
355{
356 struct inode *inode;
357 struct xfs_inode *cip = NULL;
358 struct xfs_name name;
359 int error;
360 mode_t mode;
361
362 mode = S_IFLNK |
363 (irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
364 xfs_dentry_to_name(&name, dentry);
365
366 error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip);
367 if (unlikely(error))
368 goto out;
369
370 inode = VFS_I(cip);
371
372 error = xfs_init_security(inode, dir, &dentry->d_name);
373 if (unlikely(error))
374 goto out_cleanup_inode;
375
376 d_instantiate(dentry, inode);
377 return 0;
378
379 out_cleanup_inode:
380 xfs_cleanup_inode(dir, inode, dentry);
381 out:
382 return -error;
383}
384
385STATIC int
386xfs_vn_rename(
387 struct inode *odir,
388 struct dentry *odentry,
389 struct inode *ndir,
390 struct dentry *ndentry)
391{
392 struct inode *new_inode = ndentry->d_inode;
393 struct xfs_name oname;
394 struct xfs_name nname;
395
396 xfs_dentry_to_name(&oname, odentry);
397 xfs_dentry_to_name(&nname, ndentry);
398
399 return -xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
400 XFS_I(ndir), &nname, new_inode ?
401 XFS_I(new_inode) : NULL);
402}
403
404/*
405 * careful here - this function can get called recursively, so
406 * we need to be very careful about how much stack we use.
407 * uio is kmalloced for this reason...
408 */
409STATIC void *
410xfs_vn_follow_link(
411 struct dentry *dentry,
412 struct nameidata *nd)
413{
414 char *link;
415 int error = -ENOMEM;
416
417 link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
418 if (!link)
419 goto out_err;
420
421 error = -xfs_readlink(XFS_I(dentry->d_inode), link);
422 if (unlikely(error))
423 goto out_kfree;
424
425 nd_set_link(nd, link);
426 return NULL;
427
428 out_kfree:
429 kfree(link);
430 out_err:
431 nd_set_link(nd, ERR_PTR(error));
432 return NULL;
433}
434
435STATIC void
436xfs_vn_put_link(
437 struct dentry *dentry,
438 struct nameidata *nd,
439 void *p)
440{
441 char *s = nd_get_link(nd);
442
443 if (!IS_ERR(s))
444 kfree(s);
445}
446
447STATIC int
448xfs_vn_getattr(
449 struct vfsmount *mnt,
450 struct dentry *dentry,
451 struct kstat *stat)
452{
453 struct inode *inode = dentry->d_inode;
454 struct xfs_inode *ip = XFS_I(inode);
455 struct xfs_mount *mp = ip->i_mount;
456
457 trace_xfs_getattr(ip);
458
459 if (XFS_FORCED_SHUTDOWN(mp))
460 return XFS_ERROR(EIO);
461
462 stat->size = XFS_ISIZE(ip);
463 stat->dev = inode->i_sb->s_dev;
464 stat->mode = ip->i_d.di_mode;
465 stat->nlink = ip->i_d.di_nlink;
466 stat->uid = ip->i_d.di_uid;
467 stat->gid = ip->i_d.di_gid;
468 stat->ino = ip->i_ino;
469 stat->atime = inode->i_atime;
470 stat->mtime = inode->i_mtime;
471 stat->ctime = inode->i_ctime;
472 stat->blocks =
473 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
474
475
476 switch (inode->i_mode & S_IFMT) {
477 case S_IFBLK:
478 case S_IFCHR:
479 stat->blksize = BLKDEV_IOSIZE;
480 stat->rdev = MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
481 sysv_minor(ip->i_df.if_u2.if_rdev));
482 break;
483 default:
484 if (XFS_IS_REALTIME_INODE(ip)) {
485 /*
486 * If the file blocks are being allocated from a
487 * realtime volume, then return the inode's realtime
488 * extent size or the realtime volume's extent size.
489 */
490 stat->blksize =
491 xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog;
492 } else
493 stat->blksize = xfs_preferred_iosize(mp);
494 stat->rdev = 0;
495 break;
496 }
497
498 return 0;
499}
500
501int
502xfs_setattr_nonsize(
503 struct xfs_inode *ip,
504 struct iattr *iattr,
505 int flags)
506{
507 xfs_mount_t *mp = ip->i_mount;
508 struct inode *inode = VFS_I(ip);
509 int mask = iattr->ia_valid;
510 xfs_trans_t *tp;
511 int error;
512 uid_t uid = 0, iuid = 0;
513 gid_t gid = 0, igid = 0;
514 struct xfs_dquot *udqp = NULL, *gdqp = NULL;
515 struct xfs_dquot *olddquot1 = NULL, *olddquot2 = NULL;
516
517 trace_xfs_setattr(ip);
518
519 if (mp->m_flags & XFS_MOUNT_RDONLY)
520 return XFS_ERROR(EROFS);
521
522 if (XFS_FORCED_SHUTDOWN(mp))
523 return XFS_ERROR(EIO);
524
525 error = -inode_change_ok(inode, iattr);
526 if (error)
527 return XFS_ERROR(error);
528
529 ASSERT((mask & ATTR_SIZE) == 0);
530
531 /*
532 * If disk quotas is on, we make sure that the dquots do exist on disk,
533 * before we start any other transactions. Trying to do this later
534 * is messy. We don't care to take a readlock to look at the ids
535 * in inode here, because we can't hold it across the trans_reserve.
536 * If the IDs do change before we take the ilock, we're covered
537 * because the i_*dquot fields will get updated anyway.
538 */
539 if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {
540 uint qflags = 0;
541
542 if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {
543 uid = iattr->ia_uid;
544 qflags |= XFS_QMOPT_UQUOTA;
545 } else {
546 uid = ip->i_d.di_uid;
547 }
548 if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {
549 gid = iattr->ia_gid;
550 qflags |= XFS_QMOPT_GQUOTA;
551 } else {
552 gid = ip->i_d.di_gid;
553 }
554
555 /*
556 * We take a reference when we initialize udqp and gdqp,
557 * so it is important that we never blindly double trip on
558 * the same variable. See xfs_create() for an example.
559 */
560 ASSERT(udqp == NULL);
561 ASSERT(gdqp == NULL);
562 error = xfs_qm_vop_dqalloc(ip, uid, gid, xfs_get_projid(ip),
563 qflags, &udqp, &gdqp);
564 if (error)
565 return error;
566 }
567
568 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
569 error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
570 if (error)
571 goto out_dqrele;
572
573 xfs_ilock(ip, XFS_ILOCK_EXCL);
574
575 /*
576 * Change file ownership. Must be the owner or privileged.
577 */
578 if (mask & (ATTR_UID|ATTR_GID)) {
579 /*
580 * These IDs could have changed since we last looked at them.
581 * But, we're assured that if the ownership did change
582 * while we didn't have the inode locked, inode's dquot(s)
583 * would have changed also.
584 */
585 iuid = ip->i_d.di_uid;
586 igid = ip->i_d.di_gid;
587 gid = (mask & ATTR_GID) ? iattr->ia_gid : igid;
588 uid = (mask & ATTR_UID) ? iattr->ia_uid : iuid;
589
590 /*
591 * Do a quota reservation only if uid/gid is actually
592 * going to change.
593 */
594 if (XFS_IS_QUOTA_RUNNING(mp) &&
595 ((XFS_IS_UQUOTA_ON(mp) && iuid != uid) ||
596 (XFS_IS_GQUOTA_ON(mp) && igid != gid))) {
597 ASSERT(tp);
598 error = xfs_qm_vop_chown_reserve(tp, ip, udqp, gdqp,
599 capable(CAP_FOWNER) ?
600 XFS_QMOPT_FORCE_RES : 0);
601 if (error) /* out of quota */
602 goto out_trans_cancel;
603 }
604 }
605
606 xfs_trans_ijoin(tp, ip);
607
608 /*
609 * Change file ownership. Must be the owner or privileged.
610 */
611 if (mask & (ATTR_UID|ATTR_GID)) {
612 /*
613 * CAP_FSETID overrides the following restrictions:
614 *
615 * The set-user-ID and set-group-ID bits of a file will be
616 * cleared upon successful return from chown()
617 */
618 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
619 !capable(CAP_FSETID))
620 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
621
622 /*
623 * Change the ownerships and register quota modifications
624 * in the transaction.
625 */
626 if (iuid != uid) {
627 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_UQUOTA_ON(mp)) {
628 ASSERT(mask & ATTR_UID);
629 ASSERT(udqp);
630 olddquot1 = xfs_qm_vop_chown(tp, ip,
631 &ip->i_udquot, udqp);
632 }
633 ip->i_d.di_uid = uid;
634 inode->i_uid = uid;
635 }
636 if (igid != gid) {
637 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_GQUOTA_ON(mp)) {
638 ASSERT(!XFS_IS_PQUOTA_ON(mp));
639 ASSERT(mask & ATTR_GID);
640 ASSERT(gdqp);
641 olddquot2 = xfs_qm_vop_chown(tp, ip,
642 &ip->i_gdquot, gdqp);
643 }
644 ip->i_d.di_gid = gid;
645 inode->i_gid = gid;
646 }
647 }
648
649 /*
650 * Change file access modes.
651 */
652 if (mask & ATTR_MODE) {
653 umode_t mode = iattr->ia_mode;
654
655 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
656 mode &= ~S_ISGID;
657
658 ip->i_d.di_mode &= S_IFMT;
659 ip->i_d.di_mode |= mode & ~S_IFMT;
660
661 inode->i_mode &= S_IFMT;
662 inode->i_mode |= mode & ~S_IFMT;
663 }
664
665 /*
666 * Change file access or modified times.
667 */
668 if (mask & ATTR_ATIME) {
669 inode->i_atime = iattr->ia_atime;
670 ip->i_d.di_atime.t_sec = iattr->ia_atime.tv_sec;
671 ip->i_d.di_atime.t_nsec = iattr->ia_atime.tv_nsec;
672 ip->i_update_core = 1;
673 }
674 if (mask & ATTR_CTIME) {
675 inode->i_ctime = iattr->ia_ctime;
676 ip->i_d.di_ctime.t_sec = iattr->ia_ctime.tv_sec;
677 ip->i_d.di_ctime.t_nsec = iattr->ia_ctime.tv_nsec;
678 ip->i_update_core = 1;
679 }
680 if (mask & ATTR_MTIME) {
681 inode->i_mtime = iattr->ia_mtime;
682 ip->i_d.di_mtime.t_sec = iattr->ia_mtime.tv_sec;
683 ip->i_d.di_mtime.t_nsec = iattr->ia_mtime.tv_nsec;
684 ip->i_update_core = 1;
685 }
686
687 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
688
689 XFS_STATS_INC(xs_ig_attrchg);
690
691 if (mp->m_flags & XFS_MOUNT_WSYNC)
692 xfs_trans_set_sync(tp);
693 error = xfs_trans_commit(tp, 0);
694
695 xfs_iunlock(ip, XFS_ILOCK_EXCL);
696
697 /*
698 * Release any dquot(s) the inode had kept before chown.
699 */
700 xfs_qm_dqrele(olddquot1);
701 xfs_qm_dqrele(olddquot2);
702 xfs_qm_dqrele(udqp);
703 xfs_qm_dqrele(gdqp);
704
705 if (error)
706 return XFS_ERROR(error);
707
708 /*
709 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
710 * update. We could avoid this with linked transactions
711 * and passing down the transaction pointer all the way
712 * to attr_set. No previous user of the generic
713 * Posix ACL code seems to care about this issue either.
714 */
715 if ((mask & ATTR_MODE) && !(flags & XFS_ATTR_NOACL)) {
716 error = -xfs_acl_chmod(inode);
717 if (error)
718 return XFS_ERROR(error);
719 }
720
721 return 0;
722
723out_trans_cancel:
724 xfs_trans_cancel(tp, 0);
725 xfs_iunlock(ip, XFS_ILOCK_EXCL);
726out_dqrele:
727 xfs_qm_dqrele(udqp);
728 xfs_qm_dqrele(gdqp);
729 return error;
730}
731
732/*
733 * Truncate file. Must have write permission and not be a directory.
734 */
735int
736xfs_setattr_size(
737 struct xfs_inode *ip,
738 struct iattr *iattr,
739 int flags)
740{
741 struct xfs_mount *mp = ip->i_mount;
742 struct inode *inode = VFS_I(ip);
743 int mask = iattr->ia_valid;
744 struct xfs_trans *tp;
745 int error;
746 uint lock_flags;
747 uint commit_flags = 0;
748
749 trace_xfs_setattr(ip);
750
751 if (mp->m_flags & XFS_MOUNT_RDONLY)
752 return XFS_ERROR(EROFS);
753
754 if (XFS_FORCED_SHUTDOWN(mp))
755 return XFS_ERROR(EIO);
756
757 error = -inode_change_ok(inode, iattr);
758 if (error)
759 return XFS_ERROR(error);
760
761 ASSERT(S_ISREG(ip->i_d.di_mode));
762 ASSERT((mask & (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
763 ATTR_MTIME_SET|ATTR_KILL_SUID|ATTR_KILL_SGID|
764 ATTR_KILL_PRIV|ATTR_TIMES_SET)) == 0);
765
766 lock_flags = XFS_ILOCK_EXCL;
767 if (!(flags & XFS_ATTR_NOLOCK))
768 lock_flags |= XFS_IOLOCK_EXCL;
769 xfs_ilock(ip, lock_flags);
770
771 /*
772 * Short circuit the truncate case for zero length files.
773 */
774 if (iattr->ia_size == 0 &&
775 ip->i_size == 0 && ip->i_d.di_nextents == 0) {
776 if (!(mask & (ATTR_CTIME|ATTR_MTIME)))
777 goto out_unlock;
778
779 /*
780 * Use the regular setattr path to update the timestamps.
781 */
782 xfs_iunlock(ip, lock_flags);
783 iattr->ia_valid &= ~ATTR_SIZE;
784 return xfs_setattr_nonsize(ip, iattr, 0);
785 }
786
787 /*
788 * Make sure that the dquots are attached to the inode.
789 */
790 error = xfs_qm_dqattach_locked(ip, 0);
791 if (error)
792 goto out_unlock;
793
794 /*
795 * Now we can make the changes. Before we join the inode to the
796 * transaction, take care of the part of the truncation that must be
797 * done without the inode lock. This needs to be done before joining
798 * the inode to the transaction, because the inode cannot be unlocked
799 * once it is a part of the transaction.
800 */
801 if (iattr->ia_size > ip->i_size) {
802 /*
803 * Do the first part of growing a file: zero any data in the
804 * last block that is beyond the old EOF. We need to do this
805 * before the inode is joined to the transaction to modify
806 * i_size.
807 */
808 error = xfs_zero_eof(ip, iattr->ia_size, ip->i_size);
809 if (error)
810 goto out_unlock;
811 }
812 xfs_iunlock(ip, XFS_ILOCK_EXCL);
813 lock_flags &= ~XFS_ILOCK_EXCL;
814
815 /*
816 * We are going to log the inode size change in this transaction so
817 * any previous writes that are beyond the on disk EOF and the new
818 * EOF that have not been written out need to be written here. If we
819 * do not write the data out, we expose ourselves to the null files
820 * problem.
821 *
822 * Only flush from the on disk size to the smaller of the in memory
823 * file size or the new size as that's the range we really care about
824 * here and prevents waiting for other data not within the range we
825 * care about here.
826 */
827 if (ip->i_size != ip->i_d.di_size && iattr->ia_size > ip->i_d.di_size) {
828 error = xfs_flush_pages(ip, ip->i_d.di_size, iattr->ia_size,
829 XBF_ASYNC, FI_NONE);
830 if (error)
831 goto out_unlock;
832 }
833
834 /*
835 * Wait for all I/O to complete.
836 */
837 xfs_ioend_wait(ip);
838
839 error = -block_truncate_page(inode->i_mapping, iattr->ia_size,
840 xfs_get_blocks);
841 if (error)
842 goto out_unlock;
843
844 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
845 error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
846 XFS_TRANS_PERM_LOG_RES,
847 XFS_ITRUNCATE_LOG_COUNT);
848 if (error)
849 goto out_trans_cancel;
850
851 truncate_setsize(inode, iattr->ia_size);
852
853 commit_flags = XFS_TRANS_RELEASE_LOG_RES;
854 lock_flags |= XFS_ILOCK_EXCL;
855
856 xfs_ilock(ip, XFS_ILOCK_EXCL);
857
858 xfs_trans_ijoin(tp, ip);
859
860 /*
861 * Only change the c/mtime if we are changing the size or we are
862 * explicitly asked to change it. This handles the semantic difference
863 * between truncate() and ftruncate() as implemented in the VFS.
864 *
865 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
866 * special case where we need to update the times despite not having
867 * these flags set. For all other operations the VFS set these flags
868 * explicitly if it wants a timestamp update.
869 */
870 if (iattr->ia_size != ip->i_size &&
871 (!(mask & (ATTR_CTIME | ATTR_MTIME)))) {
872 iattr->ia_ctime = iattr->ia_mtime =
873 current_fs_time(inode->i_sb);
874 mask |= ATTR_CTIME | ATTR_MTIME;
875 }
876
877 if (iattr->ia_size > ip->i_size) {
878 ip->i_d.di_size = iattr->ia_size;
879 ip->i_size = iattr->ia_size;
880 } else if (iattr->ia_size <= ip->i_size ||
881 (iattr->ia_size == 0 && ip->i_d.di_nextents)) {
882 error = xfs_itruncate_data(&tp, ip, iattr->ia_size);
883 if (error)
884 goto out_trans_abort;
885
886 /*
887 * Truncated "down", so we're removing references to old data
888 * here - if we delay flushing for a long time, we expose
889 * ourselves unduly to the notorious NULL files problem. So,
890 * we mark this inode and flush it when the file is closed,
891 * and do not wait the usual (long) time for writeout.
892 */
893 xfs_iflags_set(ip, XFS_ITRUNCATED);
894 }
895
896 if (mask & ATTR_CTIME) {
897 inode->i_ctime = iattr->ia_ctime;
898 ip->i_d.di_ctime.t_sec = iattr->ia_ctime.tv_sec;
899 ip->i_d.di_ctime.t_nsec = iattr->ia_ctime.tv_nsec;
900 ip->i_update_core = 1;
901 }
902 if (mask & ATTR_MTIME) {
903 inode->i_mtime = iattr->ia_mtime;
904 ip->i_d.di_mtime.t_sec = iattr->ia_mtime.tv_sec;
905 ip->i_d.di_mtime.t_nsec = iattr->ia_mtime.tv_nsec;
906 ip->i_update_core = 1;
907 }
908
909 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
910
911 XFS_STATS_INC(xs_ig_attrchg);
912
913 if (mp->m_flags & XFS_MOUNT_WSYNC)
914 xfs_trans_set_sync(tp);
915
916 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
917out_unlock:
918 if (lock_flags)
919 xfs_iunlock(ip, lock_flags);
920 return error;
921
922out_trans_abort:
923 commit_flags |= XFS_TRANS_ABORT;
924out_trans_cancel:
925 xfs_trans_cancel(tp, commit_flags);
926 goto out_unlock;
927}
928
929STATIC int
930xfs_vn_setattr(
931 struct dentry *dentry,
932 struct iattr *iattr)
933{
934 if (iattr->ia_valid & ATTR_SIZE)
935 return -xfs_setattr_size(XFS_I(dentry->d_inode), iattr, 0);
936 return -xfs_setattr_nonsize(XFS_I(dentry->d_inode), iattr, 0);
937}
938
939#define XFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
940
941/*
942 * Call fiemap helper to fill in user data.
943 * Returns positive errors to xfs_getbmap.
944 */
945STATIC int
946xfs_fiemap_format(
947 void **arg,
948 struct getbmapx *bmv,
949 int *full)
950{
951 int error;
952 struct fiemap_extent_info *fieinfo = *arg;
953 u32 fiemap_flags = 0;
954 u64 logical, physical, length;
955
956 /* Do nothing for a hole */
957 if (bmv->bmv_block == -1LL)
958 return 0;
959
960 logical = BBTOB(bmv->bmv_offset);
961 physical = BBTOB(bmv->bmv_block);
962 length = BBTOB(bmv->bmv_length);
963
964 if (bmv->bmv_oflags & BMV_OF_PREALLOC)
965 fiemap_flags |= FIEMAP_EXTENT_UNWRITTEN;
966 else if (bmv->bmv_oflags & BMV_OF_DELALLOC) {
967 fiemap_flags |= FIEMAP_EXTENT_DELALLOC;
968 physical = 0; /* no block yet */
969 }
970 if (bmv->bmv_oflags & BMV_OF_LAST)
971 fiemap_flags |= FIEMAP_EXTENT_LAST;
972
973 error = fiemap_fill_next_extent(fieinfo, logical, physical,
974 length, fiemap_flags);
975 if (error > 0) {
976 error = 0;
977 *full = 1; /* user array now full */
978 }
979
980 return -error;
981}
982
983STATIC int
984xfs_vn_fiemap(
985 struct inode *inode,
986 struct fiemap_extent_info *fieinfo,
987 u64 start,
988 u64 length)
989{
990 xfs_inode_t *ip = XFS_I(inode);
991 struct getbmapx bm;
992 int error;
993
994 error = fiemap_check_flags(fieinfo, XFS_FIEMAP_FLAGS);
995 if (error)
996 return error;
997
998 /* Set up bmap header for xfs internal routine */
999 bm.bmv_offset = BTOBB(start);
1000 /* Special case for whole file */
1001 if (length == FIEMAP_MAX_OFFSET)
1002 bm.bmv_length = -1LL;
1003 else
1004 bm.bmv_length = BTOBB(length);
1005
1006 /* We add one because in getbmap world count includes the header */
1007 bm.bmv_count = !fieinfo->fi_extents_max ? MAXEXTNUM :
1008 fieinfo->fi_extents_max + 1;
1009 bm.bmv_count = min_t(__s32, bm.bmv_count,
1010 (PAGE_SIZE * 16 / sizeof(struct getbmapx)));
1011 bm.bmv_iflags = BMV_IF_PREALLOC | BMV_IF_NO_HOLES;
1012 if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR)
1013 bm.bmv_iflags |= BMV_IF_ATTRFORK;
1014 if (!(fieinfo->fi_flags & FIEMAP_FLAG_SYNC))
1015 bm.bmv_iflags |= BMV_IF_DELALLOC;
1016
1017 error = xfs_getbmap(ip, &bm, xfs_fiemap_format, fieinfo);
1018 if (error)
1019 return -error;
1020
1021 return 0;
1022}
1023
1024static const struct inode_operations xfs_inode_operations = {
1025 .get_acl = xfs_get_acl,
1026 .getattr = xfs_vn_getattr,
1027 .setattr = xfs_vn_setattr,
1028 .setxattr = generic_setxattr,
1029 .getxattr = generic_getxattr,
1030 .removexattr = generic_removexattr,
1031 .listxattr = xfs_vn_listxattr,
1032 .fiemap = xfs_vn_fiemap,
1033};
1034
1035static const struct inode_operations xfs_dir_inode_operations = {
1036 .create = xfs_vn_create,
1037 .lookup = xfs_vn_lookup,
1038 .link = xfs_vn_link,
1039 .unlink = xfs_vn_unlink,
1040 .symlink = xfs_vn_symlink,
1041 .mkdir = xfs_vn_mkdir,
1042 /*
1043 * Yes, XFS uses the same method for rmdir and unlink.
1044 *
1045 * There are some subtile differences deeper in the code,
1046 * but we use S_ISDIR to check for those.
1047 */
1048 .rmdir = xfs_vn_unlink,
1049 .mknod = xfs_vn_mknod,
1050 .rename = xfs_vn_rename,
1051 .get_acl = xfs_get_acl,
1052 .getattr = xfs_vn_getattr,
1053 .setattr = xfs_vn_setattr,
1054 .setxattr = generic_setxattr,
1055 .getxattr = generic_getxattr,
1056 .removexattr = generic_removexattr,
1057 .listxattr = xfs_vn_listxattr,
1058};
1059
1060static const struct inode_operations xfs_dir_ci_inode_operations = {
1061 .create = xfs_vn_create,
1062 .lookup = xfs_vn_ci_lookup,
1063 .link = xfs_vn_link,
1064 .unlink = xfs_vn_unlink,
1065 .symlink = xfs_vn_symlink,
1066 .mkdir = xfs_vn_mkdir,
1067 /*
1068 * Yes, XFS uses the same method for rmdir and unlink.
1069 *
1070 * There are some subtile differences deeper in the code,
1071 * but we use S_ISDIR to check for those.
1072 */
1073 .rmdir = xfs_vn_unlink,
1074 .mknod = xfs_vn_mknod,
1075 .rename = xfs_vn_rename,
1076 .get_acl = xfs_get_acl,
1077 .getattr = xfs_vn_getattr,
1078 .setattr = xfs_vn_setattr,
1079 .setxattr = generic_setxattr,
1080 .getxattr = generic_getxattr,
1081 .removexattr = generic_removexattr,
1082 .listxattr = xfs_vn_listxattr,
1083};
1084
1085static const struct inode_operations xfs_symlink_inode_operations = {
1086 .readlink = generic_readlink,
1087 .follow_link = xfs_vn_follow_link,
1088 .put_link = xfs_vn_put_link,
1089 .get_acl = xfs_get_acl,
1090 .getattr = xfs_vn_getattr,
1091 .setattr = xfs_vn_setattr,
1092 .setxattr = generic_setxattr,
1093 .getxattr = generic_getxattr,
1094 .removexattr = generic_removexattr,
1095 .listxattr = xfs_vn_listxattr,
1096};
1097
1098STATIC void
1099xfs_diflags_to_iflags(
1100 struct inode *inode,
1101 struct xfs_inode *ip)
1102{
1103 if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
1104 inode->i_flags |= S_IMMUTABLE;
1105 else
1106 inode->i_flags &= ~S_IMMUTABLE;
1107 if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
1108 inode->i_flags |= S_APPEND;
1109 else
1110 inode->i_flags &= ~S_APPEND;
1111 if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
1112 inode->i_flags |= S_SYNC;
1113 else
1114 inode->i_flags &= ~S_SYNC;
1115 if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
1116 inode->i_flags |= S_NOATIME;
1117 else
1118 inode->i_flags &= ~S_NOATIME;
1119}
1120
1121/*
1122 * Initialize the Linux inode, set up the operation vectors and
1123 * unlock the inode.
1124 *
1125 * When reading existing inodes from disk this is called directly
1126 * from xfs_iget, when creating a new inode it is called from
1127 * xfs_ialloc after setting up the inode.
1128 *
1129 * We are always called with an uninitialised linux inode here.
1130 * We need to initialise the necessary fields and take a reference
1131 * on it.
1132 */
1133void
1134xfs_setup_inode(
1135 struct xfs_inode *ip)
1136{
1137 struct inode *inode = &ip->i_vnode;
1138
1139 inode->i_ino = ip->i_ino;
1140 inode->i_state = I_NEW;
1141
1142 inode_sb_list_add(inode);
1143 /* make the inode look hashed for the writeback code */
1144 hlist_add_fake(&inode->i_hash);
1145
1146 inode->i_mode = ip->i_d.di_mode;
1147 inode->i_nlink = ip->i_d.di_nlink;
1148 inode->i_uid = ip->i_d.di_uid;
1149 inode->i_gid = ip->i_d.di_gid;
1150
1151 switch (inode->i_mode & S_IFMT) {
1152 case S_IFBLK:
1153 case S_IFCHR:
1154 inode->i_rdev =
1155 MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
1156 sysv_minor(ip->i_df.if_u2.if_rdev));
1157 break;
1158 default:
1159 inode->i_rdev = 0;
1160 break;
1161 }
1162
1163 inode->i_generation = ip->i_d.di_gen;
1164 i_size_write(inode, ip->i_d.di_size);
1165 inode->i_atime.tv_sec = ip->i_d.di_atime.t_sec;
1166 inode->i_atime.tv_nsec = ip->i_d.di_atime.t_nsec;
1167 inode->i_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
1168 inode->i_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
1169 inode->i_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
1170 inode->i_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
1171 xfs_diflags_to_iflags(inode, ip);
1172
1173 switch (inode->i_mode & S_IFMT) {
1174 case S_IFREG:
1175 inode->i_op = &xfs_inode_operations;
1176 inode->i_fop = &xfs_file_operations;
1177 inode->i_mapping->a_ops = &xfs_address_space_operations;
1178 break;
1179 case S_IFDIR:
1180 if (xfs_sb_version_hasasciici(&XFS_M(inode->i_sb)->m_sb))
1181 inode->i_op = &xfs_dir_ci_inode_operations;
1182 else
1183 inode->i_op = &xfs_dir_inode_operations;
1184 inode->i_fop = &xfs_dir_file_operations;
1185 break;
1186 case S_IFLNK:
1187 inode->i_op = &xfs_symlink_inode_operations;
1188 if (!(ip->i_df.if_flags & XFS_IFINLINE))
1189 inode->i_mapping->a_ops = &xfs_address_space_operations;
1190 break;
1191 default:
1192 inode->i_op = &xfs_inode_operations;
1193 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1194 break;
1195 }
1196
1197 /*
1198 * If there is no attribute fork no ACL can exist on this inode,
1199 * and it can't have any file capabilities attached to it either.
1200 */
1201 if (!XFS_IFORK_Q(ip)) {
1202 inode_has_no_xattr(inode);
1203 cache_no_acl(inode);
1204 }
1205
1206 xfs_iflags_clear(ip, XFS_INEW);
1207 barrier();
1208
1209 unlock_new_inode(inode);
1210}
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-15 09:45:20 -0400