1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_inode.h"
14 #include "xfs_acl.h"
15 #include "xfs_quota.h"
16 #include "xfs_da_format.h"
17 #include "xfs_da_btree.h"
18 #include "xfs_attr.h"
19 #include "xfs_trans.h"
20 #include "xfs_trace.h"
21 #include "xfs_icache.h"
22 #include "xfs_symlink.h"
23 #include "xfs_dir2.h"
24 #include "xfs_iomap.h"
25 #include "xfs_error.h"
26 #include "xfs_ioctl.h"
27 #include "xfs_xattr.h"
28
29 #include <linux/posix_acl.h>
30 #include <linux/security.h>
31 #include <linux/iversion.h>
32 #include <linux/fiemap.h>
33
34 /*
35 * Directories have different lock order w.r.t. mmap_lock compared to regular
36 * files. This is due to readdir potentially triggering page faults on a user
37 * buffer inside filldir(), and this happens with the ilock on the directory
38 * held. For regular files, the lock order is the other way around - the
39 * mmap_lock is taken during the page fault, and then we lock the ilock to do
40 * block mapping. Hence we need a different class for the directory ilock so
41 * that lockdep can tell them apart.
42 */
43 static struct lock_class_key xfs_nondir_ilock_class;
44 static struct lock_class_key xfs_dir_ilock_class;
45
46 static int
xfs_initxattrs(struct inode * inode,const struct xattr * xattr_array,void * fs_info)47 xfs_initxattrs(
48 struct inode *inode,
49 const struct xattr *xattr_array,
50 void *fs_info)
51 {
52 const struct xattr *xattr;
53 struct xfs_inode *ip = XFS_I(inode);
54 int error = 0;
55
56 for (xattr = xattr_array; xattr->name != NULL; xattr++) {
57 struct xfs_da_args args = {
58 .dp = ip,
59 .attr_filter = XFS_ATTR_SECURE,
60 .name = xattr->name,
61 .namelen = strlen(xattr->name),
62 .value = xattr->value,
63 .valuelen = xattr->value_len,
64 };
65 error = xfs_attr_change(&args);
66 if (error < 0)
67 break;
68 }
69 return error;
70 }
71
72 /*
73 * Hook in SELinux. This is not quite correct yet, what we really need
74 * here (as we do for default ACLs) is a mechanism by which creation of
75 * these attrs can be journalled at inode creation time (along with the
76 * inode, of course, such that log replay can't cause these to be lost).
77 */
78
79 STATIC int
xfs_init_security(struct inode * inode,struct inode * dir,const struct qstr * qstr)80 xfs_init_security(
81 struct inode *inode,
82 struct inode *dir,
83 const struct qstr *qstr)
84 {
85 return security_inode_init_security(inode, dir, qstr,
86 &xfs_initxattrs, NULL);
87 }
88
89 static void
xfs_dentry_to_name(struct xfs_name * namep,struct dentry * dentry)90 xfs_dentry_to_name(
91 struct xfs_name *namep,
92 struct dentry *dentry)
93 {
94 namep->name = dentry->d_name.name;
95 namep->len = dentry->d_name.len;
96 namep->type = XFS_DIR3_FT_UNKNOWN;
97 }
98
99 static int
xfs_dentry_mode_to_name(struct xfs_name * namep,struct dentry * dentry,int mode)100 xfs_dentry_mode_to_name(
101 struct xfs_name *namep,
102 struct dentry *dentry,
103 int mode)
104 {
105 namep->name = dentry->d_name.name;
106 namep->len = dentry->d_name.len;
107 namep->type = xfs_mode_to_ftype(mode);
108
109 if (unlikely(namep->type == XFS_DIR3_FT_UNKNOWN))
110 return -EFSCORRUPTED;
111
112 return 0;
113 }
114
115 STATIC void
xfs_cleanup_inode(struct inode * dir,struct inode * inode,struct dentry * dentry)116 xfs_cleanup_inode(
117 struct inode *dir,
118 struct inode *inode,
119 struct dentry *dentry)
120 {
121 struct xfs_name teardown;
122
123 /* Oh, the horror.
124 * If we can't add the ACL or we fail in
125 * xfs_init_security we must back out.
126 * ENOSPC can hit here, among other things.
127 */
128 xfs_dentry_to_name(&teardown, dentry);
129
130 xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
131 }
132
133 /*
134 * Check to see if we are likely to need an extended attribute to be added to
135 * the inode we are about to allocate. This allows the attribute fork to be
136 * created during the inode allocation, reducing the number of transactions we
137 * need to do in this fast path.
138 *
139 * The security checks are optimistic, but not guaranteed. The two LSMs that
140 * require xattrs to be added here (selinux and smack) are also the only two
141 * LSMs that add a sb->s_security structure to the superblock. Hence if security
142 * is enabled and sb->s_security is set, we have a pretty good idea that we are
143 * going to be asked to add a security xattr immediately after allocating the
144 * xfs inode and instantiating the VFS inode.
145 */
146 static inline bool
xfs_create_need_xattr(struct inode * dir,struct posix_acl * default_acl,struct posix_acl * acl)147 xfs_create_need_xattr(
148 struct inode *dir,
149 struct posix_acl *default_acl,
150 struct posix_acl *acl)
151 {
152 if (acl)
153 return true;
154 if (default_acl)
155 return true;
156 #if IS_ENABLED(CONFIG_SECURITY)
157 if (dir->i_sb->s_security)
158 return true;
159 #endif
160 return false;
161 }
162
163
164 STATIC int
xfs_generic_create(struct user_namespace * mnt_userns,struct inode * dir,struct dentry * dentry,umode_t mode,dev_t rdev,bool tmpfile)165 xfs_generic_create(
166 struct user_namespace *mnt_userns,
167 struct inode *dir,
168 struct dentry *dentry,
169 umode_t mode,
170 dev_t rdev,
171 bool tmpfile) /* unnamed file */
172 {
173 struct inode *inode;
174 struct xfs_inode *ip = NULL;
175 struct posix_acl *default_acl, *acl;
176 struct xfs_name name;
177 int error;
178
179 /*
180 * Irix uses Missed'em'V split, but doesn't want to see
181 * the upper 5 bits of (14bit) major.
182 */
183 if (S_ISCHR(mode) || S_ISBLK(mode)) {
184 if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
185 return -EINVAL;
186 } else {
187 rdev = 0;
188 }
189
190 error = posix_acl_create(dir, &mode, &default_acl, &acl);
191 if (error)
192 return error;
193
194 /* Verify mode is valid also for tmpfile case */
195 error = xfs_dentry_mode_to_name(&name, dentry, mode);
196 if (unlikely(error))
197 goto out_free_acl;
198
199 if (!tmpfile) {
200 error = xfs_create(mnt_userns, XFS_I(dir), &name, mode, rdev,
201 xfs_create_need_xattr(dir, default_acl, acl),
202 &ip);
203 } else {
204 error = xfs_create_tmpfile(mnt_userns, XFS_I(dir), mode, &ip);
205 }
206 if (unlikely(error))
207 goto out_free_acl;
208
209 inode = VFS_I(ip);
210
211 error = xfs_init_security(inode, dir, &dentry->d_name);
212 if (unlikely(error))
213 goto out_cleanup_inode;
214
215 if (default_acl) {
216 error = __xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
217 if (error)
218 goto out_cleanup_inode;
219 }
220 if (acl) {
221 error = __xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
222 if (error)
223 goto out_cleanup_inode;
224 }
225
226 xfs_setup_iops(ip);
227
228 if (tmpfile) {
229 /*
230 * The VFS requires that any inode fed to d_tmpfile must have
231 * nlink == 1 so that it can decrement the nlink in d_tmpfile.
232 * However, we created the temp file with nlink == 0 because
233 * we're not allowed to put an inode with nlink > 0 on the
234 * unlinked list. Therefore we have to set nlink to 1 so that
235 * d_tmpfile can immediately set it back to zero.
236 */
237 set_nlink(inode, 1);
238 d_tmpfile(dentry, inode);
239 } else
240 d_instantiate(dentry, inode);
241
242 xfs_finish_inode_setup(ip);
243
244 out_free_acl:
245 posix_acl_release(default_acl);
246 posix_acl_release(acl);
247 return error;
248
249 out_cleanup_inode:
250 xfs_finish_inode_setup(ip);
251 if (!tmpfile)
252 xfs_cleanup_inode(dir, inode, dentry);
253 xfs_irele(ip);
254 goto out_free_acl;
255 }
256
257 STATIC int
xfs_vn_mknod(struct user_namespace * mnt_userns,struct inode * dir,struct dentry * dentry,umode_t mode,dev_t rdev)258 xfs_vn_mknod(
259 struct user_namespace *mnt_userns,
260 struct inode *dir,
261 struct dentry *dentry,
262 umode_t mode,
263 dev_t rdev)
264 {
265 return xfs_generic_create(mnt_userns, dir, dentry, mode, rdev, false);
266 }
267
268 STATIC int
xfs_vn_create(struct user_namespace * mnt_userns,struct inode * dir,struct dentry * dentry,umode_t mode,bool flags)269 xfs_vn_create(
270 struct user_namespace *mnt_userns,
271 struct inode *dir,
272 struct dentry *dentry,
273 umode_t mode,
274 bool flags)
275 {
276 return xfs_generic_create(mnt_userns, dir, dentry, mode, 0, false);
277 }
278
279 STATIC int
xfs_vn_mkdir(struct user_namespace * mnt_userns,struct inode * dir,struct dentry * dentry,umode_t mode)280 xfs_vn_mkdir(
281 struct user_namespace *mnt_userns,
282 struct inode *dir,
283 struct dentry *dentry,
284 umode_t mode)
285 {
286 return xfs_generic_create(mnt_userns, dir, dentry, mode | S_IFDIR, 0,
287 false);
288 }
289
290 STATIC struct dentry *
xfs_vn_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)291 xfs_vn_lookup(
292 struct inode *dir,
293 struct dentry *dentry,
294 unsigned int flags)
295 {
296 struct inode *inode;
297 struct xfs_inode *cip;
298 struct xfs_name name;
299 int error;
300
301 if (dentry->d_name.len >= MAXNAMELEN)
302 return ERR_PTR(-ENAMETOOLONG);
303
304 xfs_dentry_to_name(&name, dentry);
305 error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
306 if (likely(!error))
307 inode = VFS_I(cip);
308 else if (likely(error == -ENOENT))
309 inode = NULL;
310 else
311 inode = ERR_PTR(error);
312 return d_splice_alias(inode, dentry);
313 }
314
315 STATIC struct dentry *
xfs_vn_ci_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)316 xfs_vn_ci_lookup(
317 struct inode *dir,
318 struct dentry *dentry,
319 unsigned int flags)
320 {
321 struct xfs_inode *ip;
322 struct xfs_name xname;
323 struct xfs_name ci_name;
324 struct qstr dname;
325 int error;
326
327 if (dentry->d_name.len >= MAXNAMELEN)
328 return ERR_PTR(-ENAMETOOLONG);
329
330 xfs_dentry_to_name(&xname, dentry);
331 error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
332 if (unlikely(error)) {
333 if (unlikely(error != -ENOENT))
334 return ERR_PTR(error);
335 /*
336 * call d_add(dentry, NULL) here when d_drop_negative_children
337 * is called in xfs_vn_mknod (ie. allow negative dentries
338 * with CI filesystems).
339 */
340 return NULL;
341 }
342
343 /* if exact match, just splice and exit */
344 if (!ci_name.name)
345 return d_splice_alias(VFS_I(ip), dentry);
346
347 /* else case-insensitive match... */
348 dname.name = ci_name.name;
349 dname.len = ci_name.len;
350 dentry = d_add_ci(dentry, VFS_I(ip), &dname);
351 kmem_free(ci_name.name);
352 return dentry;
353 }
354
355 STATIC int
xfs_vn_link(struct dentry * old_dentry,struct inode * dir,struct dentry * dentry)356 xfs_vn_link(
357 struct dentry *old_dentry,
358 struct inode *dir,
359 struct dentry *dentry)
360 {
361 struct inode *inode = d_inode(old_dentry);
362 struct xfs_name name;
363 int error;
364
365 error = xfs_dentry_mode_to_name(&name, dentry, inode->i_mode);
366 if (unlikely(error))
367 return error;
368
369 error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
370 if (unlikely(error))
371 return error;
372
373 ihold(inode);
374 d_instantiate(dentry, inode);
375 return 0;
376 }
377
378 STATIC int
xfs_vn_unlink(struct inode * dir,struct dentry * dentry)379 xfs_vn_unlink(
380 struct inode *dir,
381 struct dentry *dentry)
382 {
383 struct xfs_name name;
384 int error;
385
386 xfs_dentry_to_name(&name, dentry);
387
388 error = xfs_remove(XFS_I(dir), &name, XFS_I(d_inode(dentry)));
389 if (error)
390 return error;
391
392 /*
393 * With unlink, the VFS makes the dentry "negative": no inode,
394 * but still hashed. This is incompatible with case-insensitive
395 * mode, so invalidate (unhash) the dentry in CI-mode.
396 */
397 if (xfs_has_asciici(XFS_M(dir->i_sb)))
398 d_invalidate(dentry);
399 return 0;
400 }
401
402 STATIC int
xfs_vn_symlink(struct user_namespace * mnt_userns,struct inode * dir,struct dentry * dentry,const char * symname)403 xfs_vn_symlink(
404 struct user_namespace *mnt_userns,
405 struct inode *dir,
406 struct dentry *dentry,
407 const char *symname)
408 {
409 struct inode *inode;
410 struct xfs_inode *cip = NULL;
411 struct xfs_name name;
412 int error;
413 umode_t mode;
414
415 mode = S_IFLNK |
416 (irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
417 error = xfs_dentry_mode_to_name(&name, dentry, mode);
418 if (unlikely(error))
419 goto out;
420
421 error = xfs_symlink(mnt_userns, XFS_I(dir), &name, symname, mode, &cip);
422 if (unlikely(error))
423 goto out;
424
425 inode = VFS_I(cip);
426
427 error = xfs_init_security(inode, dir, &dentry->d_name);
428 if (unlikely(error))
429 goto out_cleanup_inode;
430
431 xfs_setup_iops(cip);
432
433 d_instantiate(dentry, inode);
434 xfs_finish_inode_setup(cip);
435 return 0;
436
437 out_cleanup_inode:
438 xfs_finish_inode_setup(cip);
439 xfs_cleanup_inode(dir, inode, dentry);
440 xfs_irele(cip);
441 out:
442 return error;
443 }
444
445 STATIC int
xfs_vn_rename(struct user_namespace * mnt_userns,struct inode * odir,struct dentry * odentry,struct inode * ndir,struct dentry * ndentry,unsigned int flags)446 xfs_vn_rename(
447 struct user_namespace *mnt_userns,
448 struct inode *odir,
449 struct dentry *odentry,
450 struct inode *ndir,
451 struct dentry *ndentry,
452 unsigned int flags)
453 {
454 struct inode *new_inode = d_inode(ndentry);
455 int omode = 0;
456 int error;
457 struct xfs_name oname;
458 struct xfs_name nname;
459
460 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
461 return -EINVAL;
462
463 /* if we are exchanging files, we need to set i_mode of both files */
464 if (flags & RENAME_EXCHANGE)
465 omode = d_inode(ndentry)->i_mode;
466
467 error = xfs_dentry_mode_to_name(&oname, odentry, omode);
468 if (omode && unlikely(error))
469 return error;
470
471 error = xfs_dentry_mode_to_name(&nname, ndentry,
472 d_inode(odentry)->i_mode);
473 if (unlikely(error))
474 return error;
475
476 return xfs_rename(mnt_userns, XFS_I(odir), &oname,
477 XFS_I(d_inode(odentry)), XFS_I(ndir), &nname,
478 new_inode ? XFS_I(new_inode) : NULL, flags);
479 }
480
481 /*
482 * careful here - this function can get called recursively, so
483 * we need to be very careful about how much stack we use.
484 * uio is kmalloced for this reason...
485 */
486 STATIC const char *
xfs_vn_get_link(struct dentry * dentry,struct inode * inode,struct delayed_call * done)487 xfs_vn_get_link(
488 struct dentry *dentry,
489 struct inode *inode,
490 struct delayed_call *done)
491 {
492 char *link;
493 int error = -ENOMEM;
494
495 if (!dentry)
496 return ERR_PTR(-ECHILD);
497
498 link = kmalloc(XFS_SYMLINK_MAXLEN+1, GFP_KERNEL);
499 if (!link)
500 goto out_err;
501
502 error = xfs_readlink(XFS_I(d_inode(dentry)), link);
503 if (unlikely(error))
504 goto out_kfree;
505
506 set_delayed_call(done, kfree_link, link);
507 return link;
508
509 out_kfree:
510 kfree(link);
511 out_err:
512 return ERR_PTR(error);
513 }
514
515 static uint32_t
xfs_stat_blksize(struct xfs_inode * ip)516 xfs_stat_blksize(
517 struct xfs_inode *ip)
518 {
519 struct xfs_mount *mp = ip->i_mount;
520
521 /*
522 * If the file blocks are being allocated from a realtime volume, then
523 * always return the realtime extent size.
524 */
525 if (XFS_IS_REALTIME_INODE(ip))
526 return XFS_FSB_TO_B(mp, xfs_get_extsz_hint(ip));
527
528 /*
529 * Allow large block sizes to be reported to userspace programs if the
530 * "largeio" mount option is used.
531 *
532 * If compatibility mode is specified, simply return the basic unit of
533 * caching so that we don't get inefficient read/modify/write I/O from
534 * user apps. Otherwise....
535 *
536 * If the underlying volume is a stripe, then return the stripe width in
537 * bytes as the recommended I/O size. It is not a stripe and we've set a
538 * default buffered I/O size, return that, otherwise return the compat
539 * default.
540 */
541 if (xfs_has_large_iosize(mp)) {
542 if (mp->m_swidth)
543 return XFS_FSB_TO_B(mp, mp->m_swidth);
544 if (xfs_has_allocsize(mp))
545 return 1U << mp->m_allocsize_log;
546 }
547
548 return PAGE_SIZE;
549 }
550
551 STATIC int
xfs_vn_getattr(struct user_namespace * mnt_userns,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int query_flags)552 xfs_vn_getattr(
553 struct user_namespace *mnt_userns,
554 const struct path *path,
555 struct kstat *stat,
556 u32 request_mask,
557 unsigned int query_flags)
558 {
559 struct inode *inode = d_inode(path->dentry);
560 struct xfs_inode *ip = XFS_I(inode);
561 struct xfs_mount *mp = ip->i_mount;
562
563 trace_xfs_getattr(ip);
564
565 if (xfs_is_shutdown(mp))
566 return -EIO;
567
568 stat->size = XFS_ISIZE(ip);
569 stat->dev = inode->i_sb->s_dev;
570 stat->mode = inode->i_mode;
571 stat->nlink = inode->i_nlink;
572 stat->uid = i_uid_into_mnt(mnt_userns, inode);
573 stat->gid = i_gid_into_mnt(mnt_userns, inode);
574 stat->ino = ip->i_ino;
575 stat->atime = inode->i_atime;
576 stat->mtime = inode->i_mtime;
577 stat->ctime = inode->i_ctime;
578 stat->blocks = XFS_FSB_TO_BB(mp, ip->i_nblocks + ip->i_delayed_blks);
579
580 if (xfs_has_v3inodes(mp)) {
581 if (request_mask & STATX_BTIME) {
582 stat->result_mask |= STATX_BTIME;
583 stat->btime = ip->i_crtime;
584 }
585 }
586
587 /*
588 * Note: If you add another clause to set an attribute flag, please
589 * update attributes_mask below.
590 */
591 if (ip->i_diflags & XFS_DIFLAG_IMMUTABLE)
592 stat->attributes |= STATX_ATTR_IMMUTABLE;
593 if (ip->i_diflags & XFS_DIFLAG_APPEND)
594 stat->attributes |= STATX_ATTR_APPEND;
595 if (ip->i_diflags & XFS_DIFLAG_NODUMP)
596 stat->attributes |= STATX_ATTR_NODUMP;
597
598 stat->attributes_mask |= (STATX_ATTR_IMMUTABLE |
599 STATX_ATTR_APPEND |
600 STATX_ATTR_NODUMP);
601
602 switch (inode->i_mode & S_IFMT) {
603 case S_IFBLK:
604 case S_IFCHR:
605 stat->blksize = BLKDEV_IOSIZE;
606 stat->rdev = inode->i_rdev;
607 break;
608 default:
609 stat->blksize = xfs_stat_blksize(ip);
610 stat->rdev = 0;
611 break;
612 }
613
614 return 0;
615 }
616
617 static int
xfs_vn_change_ok(struct user_namespace * mnt_userns,struct dentry * dentry,struct iattr * iattr)618 xfs_vn_change_ok(
619 struct user_namespace *mnt_userns,
620 struct dentry *dentry,
621 struct iattr *iattr)
622 {
623 struct xfs_mount *mp = XFS_I(d_inode(dentry))->i_mount;
624
625 if (xfs_is_readonly(mp))
626 return -EROFS;
627
628 if (xfs_is_shutdown(mp))
629 return -EIO;
630
631 return setattr_prepare(mnt_userns, dentry, iattr);
632 }
633
634 /*
635 * Set non-size attributes of an inode.
636 *
637 * Caution: The caller of this function is responsible for calling
638 * setattr_prepare() or otherwise verifying the change is fine.
639 */
640 static int
xfs_setattr_nonsize(struct user_namespace * mnt_userns,struct xfs_inode * ip,struct iattr * iattr)641 xfs_setattr_nonsize(
642 struct user_namespace *mnt_userns,
643 struct xfs_inode *ip,
644 struct iattr *iattr)
645 {
646 xfs_mount_t *mp = ip->i_mount;
647 struct inode *inode = VFS_I(ip);
648 int mask = iattr->ia_valid;
649 xfs_trans_t *tp;
650 int error;
651 kuid_t uid = GLOBAL_ROOT_UID;
652 kgid_t gid = GLOBAL_ROOT_GID;
653 struct xfs_dquot *udqp = NULL, *gdqp = NULL;
654 struct xfs_dquot *old_udqp = NULL, *old_gdqp = NULL;
655
656 ASSERT((mask & ATTR_SIZE) == 0);
657
658 /*
659 * If disk quotas is on, we make sure that the dquots do exist on disk,
660 * before we start any other transactions. Trying to do this later
661 * is messy. We don't care to take a readlock to look at the ids
662 * in inode here, because we can't hold it across the trans_reserve.
663 * If the IDs do change before we take the ilock, we're covered
664 * because the i_*dquot fields will get updated anyway.
665 */
666 if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {
667 uint qflags = 0;
668
669 if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {
670 uid = iattr->ia_uid;
671 qflags |= XFS_QMOPT_UQUOTA;
672 } else {
673 uid = inode->i_uid;
674 }
675 if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {
676 gid = iattr->ia_gid;
677 qflags |= XFS_QMOPT_GQUOTA;
678 } else {
679 gid = inode->i_gid;
680 }
681
682 /*
683 * We take a reference when we initialize udqp and gdqp,
684 * so it is important that we never blindly double trip on
685 * the same variable. See xfs_create() for an example.
686 */
687 ASSERT(udqp == NULL);
688 ASSERT(gdqp == NULL);
689 error = xfs_qm_vop_dqalloc(ip, uid, gid, ip->i_projid,
690 qflags, &udqp, &gdqp, NULL);
691 if (error)
692 return error;
693 }
694
695 error = xfs_trans_alloc_ichange(ip, udqp, gdqp, NULL,
696 has_capability_noaudit(current, CAP_FOWNER), &tp);
697 if (error)
698 goto out_dqrele;
699
700 /*
701 * Register quota modifications in the transaction. Must be the owner
702 * or privileged. These IDs could have changed since we last looked at
703 * them. But, we're assured that if the ownership did change while we
704 * didn't have the inode locked, inode's dquot(s) would have changed
705 * also.
706 */
707 if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp) &&
708 !uid_eq(inode->i_uid, iattr->ia_uid)) {
709 ASSERT(udqp);
710 old_udqp = xfs_qm_vop_chown(tp, ip, &ip->i_udquot, udqp);
711 }
712 if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp) &&
713 !gid_eq(inode->i_gid, iattr->ia_gid)) {
714 ASSERT(xfs_has_pquotino(mp) || !XFS_IS_PQUOTA_ON(mp));
715 ASSERT(gdqp);
716 old_gdqp = xfs_qm_vop_chown(tp, ip, &ip->i_gdquot, gdqp);
717 }
718
719 setattr_copy(mnt_userns, inode, iattr);
720 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
721
722 XFS_STATS_INC(mp, xs_ig_attrchg);
723
724 if (xfs_has_wsync(mp))
725 xfs_trans_set_sync(tp);
726 error = xfs_trans_commit(tp);
727
728 /*
729 * Release any dquot(s) the inode had kept before chown.
730 */
731 xfs_qm_dqrele(old_udqp);
732 xfs_qm_dqrele(old_gdqp);
733 xfs_qm_dqrele(udqp);
734 xfs_qm_dqrele(gdqp);
735
736 if (error)
737 return error;
738
739 /*
740 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
741 * update. We could avoid this with linked transactions
742 * and passing down the transaction pointer all the way
743 * to attr_set. No previous user of the generic
744 * Posix ACL code seems to care about this issue either.
745 */
746 if (mask & ATTR_MODE) {
747 error = posix_acl_chmod(mnt_userns, inode, inode->i_mode);
748 if (error)
749 return error;
750 }
751
752 return 0;
753
754 out_dqrele:
755 xfs_qm_dqrele(udqp);
756 xfs_qm_dqrele(gdqp);
757 return error;
758 }
759
760 /*
761 * Truncate file. Must have write permission and not be a directory.
762 *
763 * Caution: The caller of this function is responsible for calling
764 * setattr_prepare() or otherwise verifying the change is fine.
765 */
766 STATIC int
xfs_setattr_size(struct user_namespace * mnt_userns,struct xfs_inode * ip,struct iattr * iattr)767 xfs_setattr_size(
768 struct user_namespace *mnt_userns,
769 struct xfs_inode *ip,
770 struct iattr *iattr)
771 {
772 struct xfs_mount *mp = ip->i_mount;
773 struct inode *inode = VFS_I(ip);
774 xfs_off_t oldsize, newsize;
775 struct xfs_trans *tp;
776 int error;
777 uint lock_flags = 0;
778 bool did_zeroing = false;
779
780 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
781 ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
782 ASSERT(S_ISREG(inode->i_mode));
783 ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
784 ATTR_MTIME_SET|ATTR_TIMES_SET)) == 0);
785
786 oldsize = inode->i_size;
787 newsize = iattr->ia_size;
788
789 /*
790 * Short circuit the truncate case for zero length files.
791 */
792 if (newsize == 0 && oldsize == 0 && ip->i_df.if_nextents == 0) {
793 if (!(iattr->ia_valid & (ATTR_CTIME|ATTR_MTIME)))
794 return 0;
795
796 /*
797 * Use the regular setattr path to update the timestamps.
798 */
799 iattr->ia_valid &= ~ATTR_SIZE;
800 return xfs_setattr_nonsize(mnt_userns, ip, iattr);
801 }
802
803 /*
804 * Make sure that the dquots are attached to the inode.
805 */
806 error = xfs_qm_dqattach(ip);
807 if (error)
808 return error;
809
810 /*
811 * Wait for all direct I/O to complete.
812 */
813 inode_dio_wait(inode);
814
815 /*
816 * File data changes must be complete before we start the transaction to
817 * modify the inode. This needs to be done before joining the inode to
818 * the transaction because the inode cannot be unlocked once it is a
819 * part of the transaction.
820 *
821 * Start with zeroing any data beyond EOF that we may expose on file
822 * extension, or zeroing out the rest of the block on a downward
823 * truncate.
824 */
825 if (newsize > oldsize) {
826 trace_xfs_zero_eof(ip, oldsize, newsize - oldsize);
827 error = xfs_zero_range(ip, oldsize, newsize - oldsize,
828 &did_zeroing);
829 } else {
830 /*
831 * iomap won't detect a dirty page over an unwritten block (or a
832 * cow block over a hole) and subsequently skips zeroing the
833 * newly post-EOF portion of the page. Flush the new EOF to
834 * convert the block before the pagecache truncate.
835 */
836 error = filemap_write_and_wait_range(inode->i_mapping, newsize,
837 newsize);
838 if (error)
839 return error;
840 error = xfs_truncate_page(ip, newsize, &did_zeroing);
841 }
842
843 if (error)
844 return error;
845
846 /*
847 * We've already locked out new page faults, so now we can safely remove
848 * pages from the page cache knowing they won't get refaulted until we
849 * drop the XFS_MMAP_EXCL lock after the extent manipulations are
850 * complete. The truncate_setsize() call also cleans partial EOF page
851 * PTEs on extending truncates and hence ensures sub-page block size
852 * filesystems are correctly handled, too.
853 *
854 * We have to do all the page cache truncate work outside the
855 * transaction context as the "lock" order is page lock->log space
856 * reservation as defined by extent allocation in the writeback path.
857 * Hence a truncate can fail with ENOMEM from xfs_trans_alloc(), but
858 * having already truncated the in-memory version of the file (i.e. made
859 * user visible changes). There's not much we can do about this, except
860 * to hope that the caller sees ENOMEM and retries the truncate
861 * operation.
862 *
863 * And we update in-core i_size and truncate page cache beyond newsize
864 * before writeback the [i_disk_size, newsize] range, so we're
865 * guaranteed not to write stale data past the new EOF on truncate down.
866 */
867 truncate_setsize(inode, newsize);
868
869 /*
870 * We are going to log the inode size change in this transaction so
871 * any previous writes that are beyond the on disk EOF and the new
872 * EOF that have not been written out need to be written here. If we
873 * do not write the data out, we expose ourselves to the null files
874 * problem. Note that this includes any block zeroing we did above;
875 * otherwise those blocks may not be zeroed after a crash.
876 */
877 if (did_zeroing ||
878 (newsize > ip->i_disk_size && oldsize != ip->i_disk_size)) {
879 error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
880 ip->i_disk_size, newsize - 1);
881 if (error)
882 return error;
883 }
884
885 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
886 if (error)
887 return error;
888
889 lock_flags |= XFS_ILOCK_EXCL;
890 xfs_ilock(ip, XFS_ILOCK_EXCL);
891 xfs_trans_ijoin(tp, ip, 0);
892
893 /*
894 * Only change the c/mtime if we are changing the size or we are
895 * explicitly asked to change it. This handles the semantic difference
896 * between truncate() and ftruncate() as implemented in the VFS.
897 *
898 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
899 * special case where we need to update the times despite not having
900 * these flags set. For all other operations the VFS set these flags
901 * explicitly if it wants a timestamp update.
902 */
903 if (newsize != oldsize &&
904 !(iattr->ia_valid & (ATTR_CTIME | ATTR_MTIME))) {
905 iattr->ia_ctime = iattr->ia_mtime =
906 current_time(inode);
907 iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
908 }
909
910 /*
911 * The first thing we do is set the size to new_size permanently on
912 * disk. This way we don't have to worry about anyone ever being able
913 * to look at the data being freed even in the face of a crash.
914 * What we're getting around here is the case where we free a block, it
915 * is allocated to another file, it is written to, and then we crash.
916 * If the new data gets written to the file but the log buffers
917 * containing the free and reallocation don't, then we'd end up with
918 * garbage in the blocks being freed. As long as we make the new size
919 * permanent before actually freeing any blocks it doesn't matter if
920 * they get written to.
921 */
922 ip->i_disk_size = newsize;
923 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
924
925 if (newsize <= oldsize) {
926 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, newsize);
927 if (error)
928 goto out_trans_cancel;
929
930 /*
931 * Truncated "down", so we're removing references to old data
932 * here - if we delay flushing for a long time, we expose
933 * ourselves unduly to the notorious NULL files problem. So,
934 * we mark this inode and flush it when the file is closed,
935 * and do not wait the usual (long) time for writeout.
936 */
937 xfs_iflags_set(ip, XFS_ITRUNCATED);
938
939 /* A truncate down always removes post-EOF blocks. */
940 xfs_inode_clear_eofblocks_tag(ip);
941 }
942
943 ASSERT(!(iattr->ia_valid & (ATTR_UID | ATTR_GID)));
944 setattr_copy(mnt_userns, inode, iattr);
945 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
946
947 XFS_STATS_INC(mp, xs_ig_attrchg);
948
949 if (xfs_has_wsync(mp))
950 xfs_trans_set_sync(tp);
951
952 error = xfs_trans_commit(tp);
953 out_unlock:
954 if (lock_flags)
955 xfs_iunlock(ip, lock_flags);
956 return error;
957
958 out_trans_cancel:
959 xfs_trans_cancel(tp);
960 goto out_unlock;
961 }
962
963 int
xfs_vn_setattr_size(struct user_namespace * mnt_userns,struct dentry * dentry,struct iattr * iattr)964 xfs_vn_setattr_size(
965 struct user_namespace *mnt_userns,
966 struct dentry *dentry,
967 struct iattr *iattr)
968 {
969 struct xfs_inode *ip = XFS_I(d_inode(dentry));
970 int error;
971
972 trace_xfs_setattr(ip);
973
974 error = xfs_vn_change_ok(mnt_userns, dentry, iattr);
975 if (error)
976 return error;
977 return xfs_setattr_size(mnt_userns, ip, iattr);
978 }
979
980 STATIC int
xfs_vn_setattr(struct user_namespace * mnt_userns,struct dentry * dentry,struct iattr * iattr)981 xfs_vn_setattr(
982 struct user_namespace *mnt_userns,
983 struct dentry *dentry,
984 struct iattr *iattr)
985 {
986 struct inode *inode = d_inode(dentry);
987 struct xfs_inode *ip = XFS_I(inode);
988 int error;
989
990 if (iattr->ia_valid & ATTR_SIZE) {
991 uint iolock;
992
993 xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
994 iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
995
996 error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);
997 if (error) {
998 xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
999 return error;
1000 }
1001
1002 error = xfs_vn_setattr_size(mnt_userns, dentry, iattr);
1003 xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
1004 } else {
1005 trace_xfs_setattr(ip);
1006
1007 error = xfs_vn_change_ok(mnt_userns, dentry, iattr);
1008 if (!error)
1009 error = xfs_setattr_nonsize(mnt_userns, ip, iattr);
1010 }
1011
1012 return error;
1013 }
1014
1015 STATIC int
xfs_vn_update_time(struct inode * inode,struct timespec64 * now,int flags)1016 xfs_vn_update_time(
1017 struct inode *inode,
1018 struct timespec64 *now,
1019 int flags)
1020 {
1021 struct xfs_inode *ip = XFS_I(inode);
1022 struct xfs_mount *mp = ip->i_mount;
1023 int log_flags = XFS_ILOG_TIMESTAMP;
1024 struct xfs_trans *tp;
1025 int error;
1026
1027 trace_xfs_update_time(ip);
1028
1029 if (inode->i_sb->s_flags & SB_LAZYTIME) {
1030 if (!((flags & S_VERSION) &&
1031 inode_maybe_inc_iversion(inode, false)))
1032 return generic_update_time(inode, now, flags);
1033
1034 /* Capture the iversion update that just occurred */
1035 log_flags |= XFS_ILOG_CORE;
1036 }
1037
1038 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp);
1039 if (error)
1040 return error;
1041
1042 xfs_ilock(ip, XFS_ILOCK_EXCL);
1043 if (flags & S_CTIME)
1044 inode->i_ctime = *now;
1045 if (flags & S_MTIME)
1046 inode->i_mtime = *now;
1047 if (flags & S_ATIME)
1048 inode->i_atime = *now;
1049
1050 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1051 xfs_trans_log_inode(tp, ip, log_flags);
1052 return xfs_trans_commit(tp);
1053 }
1054
1055 STATIC int
xfs_vn_fiemap(struct inode * inode,struct fiemap_extent_info * fieinfo,u64 start,u64 length)1056 xfs_vn_fiemap(
1057 struct inode *inode,
1058 struct fiemap_extent_info *fieinfo,
1059 u64 start,
1060 u64 length)
1061 {
1062 int error;
1063
1064 xfs_ilock(XFS_I(inode), XFS_IOLOCK_SHARED);
1065 if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
1066 fieinfo->fi_flags &= ~FIEMAP_FLAG_XATTR;
1067 error = iomap_fiemap(inode, fieinfo, start, length,
1068 &xfs_xattr_iomap_ops);
1069 } else {
1070 error = iomap_fiemap(inode, fieinfo, start, length,
1071 &xfs_read_iomap_ops);
1072 }
1073 xfs_iunlock(XFS_I(inode), XFS_IOLOCK_SHARED);
1074
1075 return error;
1076 }
1077
1078 STATIC int
xfs_vn_tmpfile(struct user_namespace * mnt_userns,struct inode * dir,struct dentry * dentry,umode_t mode)1079 xfs_vn_tmpfile(
1080 struct user_namespace *mnt_userns,
1081 struct inode *dir,
1082 struct dentry *dentry,
1083 umode_t mode)
1084 {
1085 return xfs_generic_create(mnt_userns, dir, dentry, mode, 0, true);
1086 }
1087
1088 static const struct inode_operations xfs_inode_operations = {
1089 .get_acl = xfs_get_acl,
1090 .set_acl = xfs_set_acl,
1091 .getattr = xfs_vn_getattr,
1092 .setattr = xfs_vn_setattr,
1093 .listxattr = xfs_vn_listxattr,
1094 .fiemap = xfs_vn_fiemap,
1095 .update_time = xfs_vn_update_time,
1096 .fileattr_get = xfs_fileattr_get,
1097 .fileattr_set = xfs_fileattr_set,
1098 };
1099
1100 static const struct inode_operations xfs_dir_inode_operations = {
1101 .create = xfs_vn_create,
1102 .lookup = xfs_vn_lookup,
1103 .link = xfs_vn_link,
1104 .unlink = xfs_vn_unlink,
1105 .symlink = xfs_vn_symlink,
1106 .mkdir = xfs_vn_mkdir,
1107 /*
1108 * Yes, XFS uses the same method for rmdir and unlink.
1109 *
1110 * There are some subtile differences deeper in the code,
1111 * but we use S_ISDIR to check for those.
1112 */
1113 .rmdir = xfs_vn_unlink,
1114 .mknod = xfs_vn_mknod,
1115 .rename = xfs_vn_rename,
1116 .get_acl = xfs_get_acl,
1117 .set_acl = xfs_set_acl,
1118 .getattr = xfs_vn_getattr,
1119 .setattr = xfs_vn_setattr,
1120 .listxattr = xfs_vn_listxattr,
1121 .update_time = xfs_vn_update_time,
1122 .tmpfile = xfs_vn_tmpfile,
1123 .fileattr_get = xfs_fileattr_get,
1124 .fileattr_set = xfs_fileattr_set,
1125 };
1126
1127 static const struct inode_operations xfs_dir_ci_inode_operations = {
1128 .create = xfs_vn_create,
1129 .lookup = xfs_vn_ci_lookup,
1130 .link = xfs_vn_link,
1131 .unlink = xfs_vn_unlink,
1132 .symlink = xfs_vn_symlink,
1133 .mkdir = xfs_vn_mkdir,
1134 /*
1135 * Yes, XFS uses the same method for rmdir and unlink.
1136 *
1137 * There are some subtile differences deeper in the code,
1138 * but we use S_ISDIR to check for those.
1139 */
1140 .rmdir = xfs_vn_unlink,
1141 .mknod = xfs_vn_mknod,
1142 .rename = xfs_vn_rename,
1143 .get_acl = xfs_get_acl,
1144 .set_acl = xfs_set_acl,
1145 .getattr = xfs_vn_getattr,
1146 .setattr = xfs_vn_setattr,
1147 .listxattr = xfs_vn_listxattr,
1148 .update_time = xfs_vn_update_time,
1149 .tmpfile = xfs_vn_tmpfile,
1150 .fileattr_get = xfs_fileattr_get,
1151 .fileattr_set = xfs_fileattr_set,
1152 };
1153
1154 static const struct inode_operations xfs_symlink_inode_operations = {
1155 .get_link = xfs_vn_get_link,
1156 .getattr = xfs_vn_getattr,
1157 .setattr = xfs_vn_setattr,
1158 .listxattr = xfs_vn_listxattr,
1159 .update_time = xfs_vn_update_time,
1160 };
1161
1162 /* Figure out if this file actually supports DAX. */
1163 static bool
xfs_inode_supports_dax(struct xfs_inode * ip)1164 xfs_inode_supports_dax(
1165 struct xfs_inode *ip)
1166 {
1167 struct xfs_mount *mp = ip->i_mount;
1168
1169 /* Only supported on regular files. */
1170 if (!S_ISREG(VFS_I(ip)->i_mode))
1171 return false;
1172
1173 /* Only supported on non-reflinked files. */
1174 if (xfs_is_reflink_inode(ip))
1175 return false;
1176
1177 /* Block size must match page size */
1178 if (mp->m_sb.sb_blocksize != PAGE_SIZE)
1179 return false;
1180
1181 /* Device has to support DAX too. */
1182 return xfs_inode_buftarg(ip)->bt_daxdev != NULL;
1183 }
1184
1185 static bool
xfs_inode_should_enable_dax(struct xfs_inode * ip)1186 xfs_inode_should_enable_dax(
1187 struct xfs_inode *ip)
1188 {
1189 if (!IS_ENABLED(CONFIG_FS_DAX))
1190 return false;
1191 if (xfs_has_dax_never(ip->i_mount))
1192 return false;
1193 if (!xfs_inode_supports_dax(ip))
1194 return false;
1195 if (xfs_has_dax_always(ip->i_mount))
1196 return true;
1197 if (ip->i_diflags2 & XFS_DIFLAG2_DAX)
1198 return true;
1199 return false;
1200 }
1201
1202 void
xfs_diflags_to_iflags(struct xfs_inode * ip,bool init)1203 xfs_diflags_to_iflags(
1204 struct xfs_inode *ip,
1205 bool init)
1206 {
1207 struct inode *inode = VFS_I(ip);
1208 unsigned int xflags = xfs_ip2xflags(ip);
1209 unsigned int flags = 0;
1210
1211 ASSERT(!(IS_DAX(inode) && init));
1212
1213 if (xflags & FS_XFLAG_IMMUTABLE)
1214 flags |= S_IMMUTABLE;
1215 if (xflags & FS_XFLAG_APPEND)
1216 flags |= S_APPEND;
1217 if (xflags & FS_XFLAG_SYNC)
1218 flags |= S_SYNC;
1219 if (xflags & FS_XFLAG_NOATIME)
1220 flags |= S_NOATIME;
1221 if (init && xfs_inode_should_enable_dax(ip))
1222 flags |= S_DAX;
1223
1224 /*
1225 * S_DAX can only be set during inode initialization and is never set by
1226 * the VFS, so we cannot mask off S_DAX in i_flags.
1227 */
1228 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND | S_SYNC | S_NOATIME);
1229 inode->i_flags |= flags;
1230 }
1231
1232 /*
1233 * Initialize the Linux inode.
1234 *
1235 * When reading existing inodes from disk this is called directly from xfs_iget,
1236 * when creating a new inode it is called from xfs_init_new_inode after setting
1237 * up the inode. These callers have different criteria for clearing XFS_INEW, so
1238 * leave it up to the caller to deal with unlocking the inode appropriately.
1239 */
1240 void
xfs_setup_inode(struct xfs_inode * ip)1241 xfs_setup_inode(
1242 struct xfs_inode *ip)
1243 {
1244 struct inode *inode = &ip->i_vnode;
1245 gfp_t gfp_mask;
1246
1247 inode->i_ino = ip->i_ino;
1248 inode->i_state |= I_NEW;
1249
1250 inode_sb_list_add(inode);
1251 /* make the inode look hashed for the writeback code */
1252 inode_fake_hash(inode);
1253
1254 i_size_write(inode, ip->i_disk_size);
1255 xfs_diflags_to_iflags(ip, true);
1256
1257 if (S_ISDIR(inode->i_mode)) {
1258 /*
1259 * We set the i_rwsem class here to avoid potential races with
1260 * lockdep_annotate_inode_mutex_key() reinitialising the lock
1261 * after a filehandle lookup has already found the inode in
1262 * cache before it has been unlocked via unlock_new_inode().
1263 */
1264 lockdep_set_class(&inode->i_rwsem,
1265 &inode->i_sb->s_type->i_mutex_dir_key);
1266 lockdep_set_class(&ip->i_lock.mr_lock, &xfs_dir_ilock_class);
1267 } else {
1268 lockdep_set_class(&ip->i_lock.mr_lock, &xfs_nondir_ilock_class);
1269 }
1270
1271 /*
1272 * Ensure all page cache allocations are done from GFP_NOFS context to
1273 * prevent direct reclaim recursion back into the filesystem and blowing
1274 * stacks or deadlocking.
1275 */
1276 gfp_mask = mapping_gfp_mask(inode->i_mapping);
1277 mapping_set_gfp_mask(inode->i_mapping, (gfp_mask & ~(__GFP_FS)));
1278
1279 /*
1280 * If there is no attribute fork no ACL can exist on this inode,
1281 * and it can't have any file capabilities attached to it either.
1282 */
1283 if (!XFS_IFORK_Q(ip)) {
1284 inode_has_no_xattr(inode);
1285 cache_no_acl(inode);
1286 }
1287 }
1288
1289 void
xfs_setup_iops(struct xfs_inode * ip)1290 xfs_setup_iops(
1291 struct xfs_inode *ip)
1292 {
1293 struct inode *inode = &ip->i_vnode;
1294
1295 switch (inode->i_mode & S_IFMT) {
1296 case S_IFREG:
1297 inode->i_op = &xfs_inode_operations;
1298 inode->i_fop = &xfs_file_operations;
1299 if (IS_DAX(inode))
1300 inode->i_mapping->a_ops = &xfs_dax_aops;
1301 else
1302 inode->i_mapping->a_ops = &xfs_address_space_operations;
1303 break;
1304 case S_IFDIR:
1305 if (xfs_has_asciici(XFS_M(inode->i_sb)))
1306 inode->i_op = &xfs_dir_ci_inode_operations;
1307 else
1308 inode->i_op = &xfs_dir_inode_operations;
1309 inode->i_fop = &xfs_dir_file_operations;
1310 break;
1311 case S_IFLNK:
1312 inode->i_op = &xfs_symlink_inode_operations;
1313 break;
1314 default:
1315 inode->i_op = &xfs_inode_operations;
1316 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1317 break;
1318 }
1319 }
1320