aboutsummaryrefslogtreecommitdiffstats
path: root/fs/xfs/xfs_iops.c
diff options
context:
space:
mode:
authorChristoph Hellwig <hch@infradead.org>2011-08-12 17:21:35 -0400
committerAlex Elder <aelder@sgi.com>2011-08-12 17:21:35 -0400
commitc59d87c460767bc35dafd490139d3cfe78fb8da4 (patch)
tree2aad8261f86488e501d9645bd35d1398906da46d /fs/xfs/xfs_iops.c
parent06f8e2d6754dc631732415b741b5aa58a0f7133f (diff)
xfs: remove subdirectories
Use the move from Linux 2.6 to Linux 3.x as an excuse to kill the annoying subdirectories in the XFS source code. Besides the large amount of file rename the only changes are to the Makefile, a few files including headers with the subdirectory prefix, and the binary sysctl compat code that includes a header under fs/xfs/ from kernel/. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Alex Elder <aelder@sgi.com>
Diffstat (limited to 'fs/xfs/xfs_iops.c')
-rw-r--r--fs/xfs/xfs_iops.c1210
1 files changed, 1210 insertions, 0 deletions
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
new file mode 100644
index 000000000000..b9c172b3fbbe
--- /dev/null
+++ b/fs/xfs/xfs_iops.c
@@ -0,0 +1,1210 @@
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 2024-11-14 07:23:46 -0500