Lines Matching +full:update +full:- +full:fc +full:- +full:fixup
1 /* SPDX-License-Identifier: GPL-2.0 */
15 #include <linux/radix-tree.h>
33 #include <linux/percpu-rwsem.h>
141 * Don't update ctime and mtime.
168 /* File is stream-like */
191 /* File is capable of returning -EAGAIN if I/O will block */
202 * for a file. These are the possible values of (f->f_mode &
205 * FMODE_NONOTIFY - suppress all (incl. non-permission) events.
206 * FMODE_NONOTIFY_PERM - suppress permission (incl. pre-content) events.
207 * FMODE_NONOTIFY | FMODE_NONOTIFY_PERM - suppress only pre-content events.
226 * Attribute flags. These should be or-ed together to figure out what
262 * Derek Atkins <[email protected]> 94-10-20
312 * enum positive_aop_returns - aop return codes with specific semantics
317 * to return the page to the active list -- it won't
359 /* non-RWF related bits - start at 16 */
363 /* iocb->ki_waitq is valid */
372 * flag is set, the bio completion handling may set iocb->dio_complete to a
373 * handler function and iocb->private to context information for that handler.
377 * used on the completion side for non-IO generating completions. It's fine to
423 * assigned to ->private when dio_complete is assigned.
431 return kiocb->ki_complete == NULL; in is_sync_kiocb()
481 * struct address_space - Contents of a cacheable, mappable object.
485 * file offset->disk block mappings in the filesystem during invalidates.
490 * @nr_thps: Number of THPs in the pagecache (non-shmem only).
509 /* number of thp, only for non-shmem files */
539 return xa_marked(&mapping->i_pages, tag); in mapping_tagged()
544 down_write(&mapping->i_mmap_rwsem); in i_mmap_lock_write()
549 return down_write_trylock(&mapping->i_mmap_rwsem); in i_mmap_trylock_write()
554 up_write(&mapping->i_mmap_rwsem); in i_mmap_unlock_write()
559 return down_read_trylock(&mapping->i_mmap_rwsem); in i_mmap_trylock_read()
564 down_read(&mapping->i_mmap_rwsem); in i_mmap_lock_read()
569 up_read(&mapping->i_mmap_rwsem); in i_mmap_unlock_read()
574 lockdep_assert_held(&mapping->i_mmap_rwsem); in i_mmap_assert_locked()
579 lockdep_assert_held_write(&mapping->i_mmap_rwsem); in i_mmap_assert_write_locked()
587 return !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root); in mapping_mapped()
601 return atomic_read(&mapping->i_mmap_writable) > 0; in mapping_writably_mapped()
606 return atomic_inc_unless_negative(&mapping->i_mmap_writable) ? in mapping_map_writable()
607 0 : -EPERM; in mapping_map_writable()
612 atomic_dec(&mapping->i_mmap_writable); in mapping_unmap_writable()
617 return atomic_dec_unless_positive(&mapping->i_mmap_writable) ? in mapping_deny_writable()
618 0 : -EBUSY; in mapping_deny_writable()
623 atomic_inc(&mapping->i_mmap_writable); in mapping_allow_writable()
627 * Use sequence counter to get consistent i_size on 32-bit processors.
632 #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
638 #define ACL_NOT_CACHED ((void *)(-1))
641 * cache the ACL. This also means that ->get_inode_acl() can be called in RCU
644 #define ACL_DONT_CACHE ((void *)(-3))
667 * Keep mostly read-only and often accessed (especially for
725 /* 32-bit hole */
757 const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
776 /* 32-bit hole reserved for expanding i_fsnotify_mask */
796 * TODO: patch it into a debug-only check if relevant macros show up. in inode_set_cached_link()
798 * to find the right length, do a fixup if the wrong value got passed. in inode_set_cached_link()
806 inode->i_link = link; in inode_set_cached_link()
807 inode->i_linklen = linklen; in inode_set_cached_link()
808 inode->i_opflags |= IOP_CACHED_LINK; in inode_set_cached_link()
812 * Get bit address from inode->i_state to use with wait_var_event()
815 #define inode_state_wait_address(inode, bit) ((char *)&(inode)->i_state + (bit))
830 return (1 << node->i_blkbits); in i_blocksize()
835 return hlist_unhashed(&inode->i_hash); in inode_unhashed()
846 hlist_add_fake(&inode->i_hash); in inode_fake_hash()
850 * inode->i_mutex nesting subclasses for the lock validator:
856 * 4: second non-directory
860 * non-directories at once.
863 * parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory
877 down_write(&inode->i_rwsem); in inode_lock()
882 up_write(&inode->i_rwsem); in inode_unlock()
887 down_read(&inode->i_rwsem); in inode_lock_shared()
892 up_read(&inode->i_rwsem); in inode_unlock_shared()
897 return down_write_trylock(&inode->i_rwsem); in inode_trylock()
902 return down_read_trylock(&inode->i_rwsem); in inode_trylock_shared()
907 return rwsem_is_locked(&inode->i_rwsem); in inode_is_locked()
912 down_write_nested(&inode->i_rwsem, subclass); in inode_lock_nested()
917 down_read_nested(&inode->i_rwsem, subclass); in inode_lock_shared_nested()
922 down_write(&mapping->invalidate_lock); in filemap_invalidate_lock()
927 up_write(&mapping->invalidate_lock); in filemap_invalidate_unlock()
932 down_read(&mapping->invalidate_lock); in filemap_invalidate_lock_shared()
938 return down_read_trylock(&mapping->invalidate_lock); in filemap_invalidate_trylock_shared()
944 up_read(&mapping->invalidate_lock); in filemap_invalidate_unlock_shared()
973 seq = read_seqcount_begin(&inode->i_size_seqcount); in i_size_read()
974 i_size = inode->i_size; in i_size_read()
975 } while (read_seqcount_retry(&inode->i_size_seqcount, seq)); in i_size_read()
981 i_size = inode->i_size; in i_size_read()
986 return smp_load_acquire(&inode->i_size); in i_size_read()
992 * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
999 write_seqcount_begin(&inode->i_size_seqcount); in i_size_write()
1000 inode->i_size = i_size; in i_size_write()
1001 write_seqcount_end(&inode->i_size_seqcount); in i_size_write()
1005 inode->i_size = i_size; in i_size_write()
1013 smp_store_release(&inode->i_size, i_size); in i_size_write()
1019 return MINOR(inode->i_rdev); in iminor()
1024 return MAJOR(inode->i_rdev); in imajor()
1030 struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
1037 * struct file_ra_state - Track a file's readahead state.
1047 * When this structure is passed to ->readahead(), the "most recent"
1064 return (index >= ra->start && in ra_has_index()
1065 index < ra->start + ra->size); in ra_has_index()
1069 * struct file - Represents a file
1105 /* --- cacheline 1 boundary (64 bytes) --- */
1117 /* --- cacheline 2 boundary (128 bytes) --- */
1130 /* --- cacheline 3 boundary (192 bytes) --- */
1143 file_ref_inc(&f->f_ref); in get_file()
1150 #define file_count(f) file_ref_read(&(f)->f_ref)
1152 #define MAX_NON_LFS ((1UL<<31) - 1)
1177 return READ_ONCE(file->f_owner); in file_f_owner()
1184 return f->f_inode; in file_inode()
1197 struct dentry *dentry = file->f_path.dentry; in file_dentry()
1231 * sb->s_flags. Note that these mirror the equivalent MS_* flags where
1234 #define SB_RDONLY BIT(0) /* Mount read-only */
1241 #define SB_NOATIME BIT(10) /* Do not update access times. */
1242 #define SB_NODIRATIME BIT(11) /* Do not update directory access times */
1245 #define SB_INLINECRYPT BIT(17) /* Use blk-crypto for encrypted files */
1247 #define SB_I_VERSION BIT(23) /* Update inode I_version field */
1248 #define SB_LAZYTIME BIT(25) /* Update the on-disk [acm]times lazily */
1264 (sb->s_encoding_flags & SB_ENC_STRICT_MODE_FL)
1276 /* sb->s_iflags */
1277 #define SB_I_CGROUPWB 0x00000001 /* cgroup-aware writeback enabled */
1282 /* sb->s_iflags to limit user namespace mounts */
1289 #define SB_I_PERSB_BDI 0x00000200 /* has a per-sb bdi */
1303 SB_FREEZE_COMPLETE = 4, /* ->freeze_fs finished successfully */
1306 #define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
1403 * Filesystem subtype. If non-empty the filesystem type field
1410 struct shrinker *s_shrink; /* per-sb shrinker handle */
1415 /* Read-only state of the superblock is being changed */
1418 /* per-sb errseq_t for reporting writeback errors via syncfs */
1434 * of per-node lru lists, each of which has its own spinlock.
1459 return inode->i_sb->s_user_ns; in i_user_ns()
1469 return from_kuid(i_user_ns(inode), inode->i_uid); in i_uid_read()
1474 return from_kgid(i_user_ns(inode), inode->i_gid); in i_gid_read()
1479 inode->i_uid = make_kuid(i_user_ns(inode), uid); in i_uid_write()
1484 inode->i_gid = make_kgid(i_user_ns(inode), gid); in i_gid_write()
1488 * i_uid_into_vfsuid - map an inode's i_uid down according to an idmapping
1498 return make_vfsuid(idmap, i_user_ns(inode), inode->i_uid); in i_uid_into_vfsuid()
1502 * i_uid_needs_update - check whether inode's i_uid needs to be updated
1505 * @inode: the inode to update
1516 return ((attr->ia_valid & ATTR_UID) && in i_uid_needs_update()
1517 !vfsuid_eq(attr->ia_vfsuid, in i_uid_needs_update()
1522 * i_uid_update - update @inode's i_uid field
1525 * @inode: the inode to update
1527 * Safely update @inode's i_uid field translating the vfsuid of any idmapped
1534 if (attr->ia_valid & ATTR_UID) in i_uid_update()
1535 inode->i_uid = from_vfsuid(idmap, i_user_ns(inode), in i_uid_update()
1536 attr->ia_vfsuid); in i_uid_update()
1540 * i_gid_into_vfsgid - map an inode's i_gid down according to an idmapping
1550 return make_vfsgid(idmap, i_user_ns(inode), inode->i_gid); in i_gid_into_vfsgid()
1554 * i_gid_needs_update - check whether inode's i_gid needs to be updated
1557 * @inode: the inode to update
1568 return ((attr->ia_valid & ATTR_GID) && in i_gid_needs_update()
1569 !vfsgid_eq(attr->ia_vfsgid, in i_gid_needs_update()
1574 * i_gid_update - update @inode's i_gid field
1577 * @inode: the inode to update
1579 * Safely update @inode's i_gid field translating the vfsgid of any idmapped
1586 if (attr->ia_valid & ATTR_GID) in i_gid_update()
1587 inode->i_gid = from_vfsgid(idmap, i_user_ns(inode), in i_gid_update()
1588 attr->ia_vfsgid); in i_gid_update()
1592 * inode_fsuid_set - initialize inode's i_uid field with callers fsuid
1602 inode->i_uid = mapped_fsuid(idmap, i_user_ns(inode)); in inode_fsuid_set()
1606 * inode_fsgid_set - initialize inode's i_gid field with callers fsgid
1616 inode->i_gid = mapped_fsgid(idmap, i_user_ns(inode)); in inode_fsgid_set()
1620 * fsuidgid_has_mapping() - check whether caller's fsuid/fsgid is mapped
1633 struct user_namespace *fs_userns = sb->s_user_ns; in fsuidgid_has_mapping()
1650 struct timespec64 update);
1654 return inode->i_atime_sec; in inode_get_atime_sec()
1659 return inode->i_atime_nsec; in inode_get_atime_nsec()
1673 inode->i_atime_sec = ts.tv_sec; in inode_set_atime_to_ts()
1674 inode->i_atime_nsec = ts.tv_nsec; in inode_set_atime_to_ts()
1689 return inode->i_mtime_sec; in inode_get_mtime_sec()
1694 return inode->i_mtime_nsec; in inode_get_mtime_nsec()
1707 inode->i_mtime_sec = ts.tv_sec; in inode_set_mtime_to_ts()
1708 inode->i_mtime_nsec = ts.tv_nsec; in inode_set_mtime_to_ts()
1723 * Conditionally use fine-grained ctime and mtime timestamps when there
1724 * are users actively observing them via getattr. The primary use-case
1727 * operations that occur in the same coarse-grained timer tick.
1733 return inode->i_ctime_sec; in inode_get_ctime_sec()
1738 return inode->i_ctime_nsec & ~I_CTIME_QUERIED; in inode_get_ctime_nsec()
1752 * inode_set_ctime - set the ctime in the inode
1780 percpu_up_read(sb->s_writers.rw_sem + level-1); in __sb_end_write()
1785 percpu_down_read(sb->s_writers.rw_sem + level - 1); in __sb_start_write()
1790 return percpu_down_read_trylock(sb->s_writers.rw_sem + level - 1); in __sb_start_write_trylock()
1794 percpu_rwsem_acquire(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1796 percpu_rwsem_release(&(sb)->s_writers.rw_sem[(lev)-1], _THIS_IP_)
1799 * __sb_write_started - check if sb freeze level is held
1803 * * > 0 - sb freeze level is held
1804 * * 0 - sb freeze level is not held
1805 * * < 0 - !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN
1809 return lockdep_is_held_type(sb->s_writers.rw_sem + level - 1, 1); in __sb_write_started()
1813 * sb_write_started - check if SB_FREEZE_WRITE is held
1824 * sb_write_not_started - check if SB_FREEZE_WRITE is not held
1835 * file_write_started - check if SB_FREEZE_WRITE is held
1844 if (!S_ISREG(file_inode(file)->i_mode)) in file_write_started()
1846 return sb_write_started(file_inode(file)->i_sb); in file_write_started()
1850 * file_write_not_started - check if SB_FREEZE_WRITE is not held
1859 if (!S_ISREG(file_inode(file)->i_mode)) in file_write_not_started()
1861 return sb_write_not_started(file_inode(file)->i_sb); in file_write_not_started()
1865 * sb_end_write - drop write access to a superblock
1877 * sb_end_pagefault - drop write access to a superblock from a page fault
1889 * sb_end_intwrite - drop write access to a superblock for internal fs purposes
1892 * Decrement fs-internal number of writers to the filesystem. Wake up possible
1901 * sb_start_write - get write access to a superblock
1905 * a page or an inode), it should embed the operation in a sb_start_write() -
1916 * -> i_mutex (write path, truncate, directory ops, ...)
1917 * -> s_umount (freeze_super, thaw_super)
1930 * sb_start_pagefault - get write access to a superblock from a page fault
1934 * operation into sb_start_pagefault() - sb_end_pagefault() pair to get
1946 * -> sb_start_pagefault
1954 * sb_start_intwrite - get write access to a superblock for internal fs purposes
1997 * struct renamedata - contains all information required for renaming
2182 /* Supports non-exclusive O_DIRECT writes from multiple threads */
2245 return file->f_op->mmap(file, vma); in call_mmap()
2270 * enum freeze_holder - holder of the freeze
2325 * Inode flags - they have no relation to superblock flags now
2328 #define S_NOATIME (1 << 1) /* Do not update access times */
2329 #define S_APPEND (1 << 2) /* Append-only file */
2334 #define S_NOCMTIME (1 << 7) /* Do not update file c/mtime */
2336 #define S_PRIVATE (1 << 9) /* Inode is fs-internal */
2338 #define S_AUTOMOUNT (1 << 11) /* Automount/referral quasi-directory */
2351 * Note that nosuid etc flags are inode-specific: setting some file-system
2361 * flags, so these have to be checked separately. -- [email protected]
2363 #define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
2365 static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; } in sb_rdonly()
2366 #define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
2368 ((inode)->i_flags & S_SYNC))
2370 ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
2375 #define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
2376 #define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
2377 #define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
2385 #define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
2386 #define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
2389 #define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
2394 #define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
2395 #define IS_IMA(inode) ((inode)->i_flags & S_IMA)
2396 #define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
2397 #define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
2398 #define IS_DAX(inode) ((inode)->i_flags & S_DAX)
2399 #define IS_ENCRYPTED(inode) ((inode)->i_flags & S_ENCRYPTED)
2400 #define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD)
2401 #define IS_VERITY(inode) ((inode)->i_flags & S_VERITY)
2403 #define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \
2404 (inode)->i_rdev == WHITEOUT_DEV)
2417 .ki_flags = filp->f_iocb_flags, in init_sync_kiocb()
2427 .ki_flags = kiocb_src->ki_flags, in kiocb_clone()
2428 .ki_ioprio = kiocb_src->ki_ioprio, in kiocb_clone()
2429 .ki_pos = kiocb_src->ki_pos, in kiocb_clone()
2434 * Inode state bits. Protected by inode->i_lock
2448 * I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
2460 * and we don't want to lose the time update
2468 * nearly-dead inodes.
2560 * located very nearby on-disk, e.g. in the same inode block. This returns true
2561 * if the given inode is in need of such an opportunistic update. Requires
2562 * i_lock, or at least later re-checking under i_lock.
2566 return (inode->i_state & (I_DIRTY_TIME | I_NEW | in inode_is_dirtytime_only()
2600 if (!(file->f_flags & O_NOATIME)) in file_accessed()
2601 touch_atime(&file->f_path); in file_accessed()
2640 #define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
2650 return inode->i_opflags & IOP_MGTIME; in is_mgtime()
2671 int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
2674 struct super_block *sget_fc(struct fs_context *fc,
2681 struct super_block *sget_dev(struct fs_context *fc, dev_t dev);
2686 (((_fops) && try_module_get((_fops)->owner) ? (_fops) : NULL)); \
2692 module_put((_fops)->owner); \
2696 * This one is to be used *ONLY* from ->open() instances.
2697 * fops must be non-NULL, pinned down *and* module dependencies
2703 fops_put(__file->f_op); \
2704 BUG_ON(!(__file->f_op = (fops))); \
2720 if (WARN_ON(len > sizeof(sb->s_uuid))) in super_set_uuid()
2721 len = sizeof(sb->s_uuid); in super_set_uuid()
2722 sb->s_uuid_len = len; in super_set_uuid()
2723 memcpy(&sb->s_uuid, uuid, len); in super_set_uuid()
2726 /* set sb sysfs name based on sb->s_bdev */
2729 snprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), "%pg", sb->s_bdev); in super_set_sysfs_name_bdev()
2732 /* set sb sysfs name based on sb->s_uuid */
2735 WARN_ON(sb->s_uuid_len != sizeof(sb->s_uuid)); in super_set_sysfs_name_uuid()
2736 snprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), "%pU", sb->s_uuid.b); in super_set_sysfs_name_uuid()
2739 /* set sb sysfs name based on sb->s_id */
2742 strscpy(sb->s_sysfs_name, sb->s_id, sizeof(sb->s_sysfs_name)); in super_set_sysfs_name_id()
2752 vsnprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), fmt, args); in super_set_sysfs_name_generic()
2781 return mnt_idmap(file->f_path.mnt); in file_mnt_idmap()
2785 * is_idmapped_mnt - check whether a mount is mapped
2811 return file_open_root(&(struct path){.mnt = mnt, .dentry = mnt->mnt_root}, in file_open_root_mnt()
2824 * stored in ->vm_file is a backing file whose f_inode is on the underlying
2834 if (unlikely(f->f_mode & FMODE_BACKING)) in file_user_path()
2836 return &f->f_path; in file_user_path()
2841 if (unlikely(f->f_mode & FMODE_BACKING)) in file_user_inode()
2842 return d_inode(backing_file_user_path(f)->dentry); in file_user_inode()
2848 return dentry_open(&file->f_path, file->f_flags, file->f_cred); in file_clone_open()
2878 return finish_open(file, file->f_path.dentry, NULL); in finish_open_simple()
2932 /* Invalid inode operations -- fs/bad_inode.c */
2958 return (iocb->ki_flags & IOCB_DSYNC) || in iocb_is_dsync()
2959 IS_SYNC(iocb->ki_filp->f_mapping->host); in iocb_is_dsync()
2970 int ret = vfs_fsync_range(iocb->ki_filp, in generic_write_sync()
2971 iocb->ki_pos - count, iocb->ki_pos - 1, in generic_write_sync()
2972 (iocb->ki_flags & IOCB_SYNC) ? 0 : 1); in generic_write_sync()
2975 } else if (iocb->ki_flags & IOCB_DONTCACHE) { in generic_write_sync()
2976 struct address_space *mapping = iocb->ki_filp->f_mapping; in generic_write_sync()
2978 filemap_fdatawrite_range_kick(mapping, iocb->ki_pos - count, in generic_write_sync()
2979 iocb->ki_pos - 1); in generic_write_sync()
2993 return -EINVAL; in bmap()
3008 return inode_permission(mnt_idmap(path->mnt), in path_permission()
3009 d_inode(path->dentry), mask); in path_permission()
3016 return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode); in execute_ok()
3021 return (inode->i_mode ^ mode) & S_IFMT; in inode_wrong_type()
3025 * file_start_write - get write access to a superblock for regular file io
3028 * This is a variant of sb_start_write() which is a noop on non-regualr file.
3033 if (!S_ISREG(file_inode(file)->i_mode)) in file_start_write()
3035 sb_start_write(file_inode(file)->i_sb); in file_start_write()
3040 if (!S_ISREG(file_inode(file)->i_mode)) in file_start_write_trylock()
3042 return sb_start_write_trylock(file_inode(file)->i_sb); in file_start_write_trylock()
3046 * file_end_write - drop write access to a superblock of a regular file
3053 if (!S_ISREG(file_inode(file)->i_mode)) in file_end_write()
3055 sb_end_write(file_inode(file)->i_sb); in file_end_write()
3059 * kiocb_start_write - get write access to a superblock for async file io
3067 struct inode *inode = file_inode(iocb->ki_filp); in kiocb_start_write()
3069 sb_start_write(inode->i_sb); in kiocb_start_write()
3074 __sb_writers_release(inode->i_sb, SB_FREEZE_WRITE); in kiocb_start_write()
3078 * kiocb_end_write - drop write access to a superblock after async file io
3085 struct inode *inode = file_inode(iocb->ki_filp); in kiocb_end_write()
3090 __sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE); in kiocb_end_write()
3091 sb_end_write(inode->i_sb); in kiocb_end_write()
3095 * This is used for regular files where some users -- especially the
3097 * VM_DENYWRITE -- cannot handle concurrent write (and maybe mmap
3098 * read-write shared) accesses.
3103 * allow_write_access() re-enables write access to a file.
3107 * < 0: (-i_writecount) users that denied write access to the file.
3112 * use {get,deny}_write_access() - these functions check the sign and refuse
3117 return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY; in get_write_access()
3122 return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY; in deny_write_access()
3126 atomic_dec(&inode->i_writecount); in put_write_access()
3131 atomic_inc(&file_inode(file)->i_writecount); in allow_write_access()
3135 * Do not prevent write to executable file when watched by pre-content events.
3137 * Note that FMODE_FSNOTIFY_HSM mode is set depending on pre-content watches at
3139 * so if pre-content watches are added post execution or removed before the end
3144 if (unlikely(FMODE_FSNOTIFY_HSM(exe_file->f_mode))) in exe_file_deny_write_access()
3150 if (unlikely(!exe_file || FMODE_FSNOTIFY_HSM(exe_file->f_mode))) in exe_file_allow_write_access()
3157 file->f_mode &= ~FMODE_FSNOTIFY_MASK; in file_set_fsnotify_mode()
3158 file->f_mode |= mode; in file_set_fsnotify_mode()
3163 return atomic_read(&inode->i_writecount) > 0; in inode_is_open_for_write()
3169 BUG_ON(atomic_dec_return(&inode->i_readcount) < 0); in i_readcount_dec()
3173 atomic_inc(&inode->i_readcount); in i_readcount_inc()
3193 /* fs/dcache.c -- generic fs support functions */
3200 * is_dot_dotdot - returns true only if @name is "." or ".."
3231 return !inode->i_nlink || inode_unhashed(inode); in generic_drop_inode()
3275 * Userspace may rely on the inode number being non-zero. For example, glibc
3279 * _FILE_OFFSET_BITS=32 on a 64-bit kernel we'll only end up reading out the
3281 * _FILE_OFFSET_BITS=64, this may cause some harmless false-negatives, but
3290 * inode->i_lock must be held
3294 atomic_inc(&inode->i_count); in __iget()
3313 #define alloc_inode_sb(_sb, _cache, _gfp) kmem_cache_alloc_lru(_cache, &_sb->s_inode_lru, _gfp)
3318 __insert_inode_hash(inode, inode->i_ino); in insert_inode_hash()
3324 if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash)) in remove_inode_hash()
3412 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter, in blockdev_direct_IO()
3422 * inode_dio_begin - signal start of a direct I/O requests
3430 atomic_inc(&inode->i_dio_count); in inode_dio_begin()
3434 * inode_dio_end - signal finish of a direct I/O requests
3442 if (atomic_dec_and_test(&inode->i_dio_count)) in inode_dio_end()
3443 wake_up_var(&inode->i_dio_count); in inode_dio_end()
3477 return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes; in __inode_get_bytes()
3599 * generic_ci_validate_strict_name - Check if a given name is suitable
3603 * parent directory. That means that only valid UTF-8 filenames will be
3622 if (!IS_CASEFOLDED(dir) || !sb_has_strict_encoding(dir->i_sb)) in generic_ci_validate_strict_name()
3629 if (WARN_ON_ONCE(!dir->i_sb->s_encoding)) in generic_ci_validate_strict_name()
3632 return !utf8_validate(dir->i_sb->s_encoding, name); in generic_ci_validate_strict_name()
3644 return !!sb->s_encoding; in sb_has_encoding()
3661 return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host); in vma_is_dax()
3668 if (!IS_ENABLED(CONFIG_FS_DAX) || !vma->vm_file) in vma_is_fsdax()
3672 inode = file_inode(vma->vm_file); in vma_is_fsdax()
3673 if (S_ISCHR(inode->i_mode)) in vma_is_fsdax()
3674 return false; /* device-dax */ in vma_is_fsdax()
3681 if (file->f_flags & O_APPEND) in iocb_flags()
3683 if (file->f_flags & O_DIRECT) in iocb_flags()
3685 if (file->f_flags & O_DSYNC) in iocb_flags()
3687 if (file->f_flags & __O_SYNC) in iocb_flags()
3703 return -EOPNOTSUPP; in kiocb_set_rw_flags()
3705 return -EINVAL; in kiocb_set_rw_flags()
3708 if (!(ki->ki_filp->f_mode & FMODE_NOWAIT)) in kiocb_set_rw_flags()
3709 return -EOPNOTSUPP; in kiocb_set_rw_flags()
3713 return -EOPNOTSUPP; in kiocb_set_rw_flags()
3714 if (!(ki->ki_filp->f_mode & FMODE_CAN_ATOMIC_WRITE)) in kiocb_set_rw_flags()
3715 return -EOPNOTSUPP; in kiocb_set_rw_flags()
3719 if (!(ki->ki_filp->f_op->fop_flags & FOP_DONTCACHE)) in kiocb_set_rw_flags()
3720 return -EOPNOTSUPP; in kiocb_set_rw_flags()
3722 if (IS_DAX(ki->ki_filp->f_mapping->host)) in kiocb_set_rw_flags()
3723 return -EOPNOTSUPP; in kiocb_set_rw_flags()
3729 if ((flags & RWF_NOAPPEND) && (ki->ki_flags & IOCB_APPEND)) { in kiocb_set_rw_flags()
3730 if (IS_APPEND(file_inode(ki->ki_filp))) in kiocb_set_rw_flags()
3731 return -EPERM; in kiocb_set_rw_flags()
3732 ki->ki_flags &= ~IOCB_APPEND; in kiocb_set_rw_flags()
3735 ki->ki_flags |= kiocb_flags; in kiocb_set_rw_flags()
3750 #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
3830 if (!(dir->i_mode & S_ISVTX)) in check_sticky()
3838 if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & SB_NOSEC)) in inode_has_no_xattr()
3839 inode->i_flags |= S_NOSEC; in inode_has_no_xattr()
3844 return inode == inode->i_sb->s_root->d_inode; in is_root_inode()
3851 return ctx->actor(ctx, name, namelen, ctx->pos, ino, type); in dir_emit()
3855 return ctx->actor(ctx, ".", 1, ctx->pos, in dir_emit_dot()
3856 file->f_path.dentry->d_inode->i_ino, DT_DIR); in dir_emit_dot()
3860 return ctx->actor(ctx, "..", 2, ctx->pos, in dir_emit_dotdot()
3861 d_parent_ino(file->f_path.dentry), DT_DIR); in dir_emit_dotdot()
3865 if (ctx->pos == 0) { in dir_emit_dots()
3868 ctx->pos = 1; in dir_emit_dots()
3870 if (ctx->pos == 1) { in dir_emit_dots()
3873 ctx->pos = 2; in dir_emit_dots()