/* * Obtain attributes of an object given a dentry */ int orangefs_getattr(const struct path *path, struct kstat *stat, u32 request_mask, unsigned int flags) { int ret = -ENOENT; struct inode *inode = path->dentry->d_inode; struct orangefs_inode_s *orangefs_inode = NULL; gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_getattr: called on %pd\n", path->dentry); ret = orangefs_inode_getattr(inode, 0, 0, request_mask); if (ret == 0) { generic_fillattr(inode, stat); /* override block size reported to stat */ orangefs_inode = ORANGEFS_I(inode); stat->blksize = orangefs_inode->blksize; if (request_mask & STATX_SIZE) stat->result_mask = STATX_BASIC_STATS; else stat->result_mask = STATX_BASIC_STATS & ~STATX_SIZE; } return ret; }
int fuse_update_attributes(struct inode *inode, struct kstat *stat, struct file *file, bool *refreshed) { struct fuse_inode *fi = get_fuse_inode(inode); int err; bool r; if (fi->i_time < get_jiffies_64()) { r = true; err = fuse_do_getattr(inode, stat, file); } else { r = false; err = 0; if (stat) { generic_fillattr(inode, stat); stat->mode = fi->orig_i_mode; stat->ino = fi->orig_ino; } } if (refreshed != NULL) *refreshed = r; return err; }
int ocfs2_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct inode *inode = dentry->d_inode; struct super_block *sb = dentry->d_inode->i_sb; struct ocfs2_super *osb = sb->s_fs_info; int err; mlog_entry_void(); err = ocfs2_inode_revalidate(dentry); if (err) { if (err != -ENOENT) mlog_errno(err); goto bail; } generic_fillattr(inode, stat); /* We set the blksize from the cluster size for performance */ stat->blksize = osb->s_clustersize; bail: mlog_exit(err); return err; }
static int fuse_update_get_attr(struct inode *inode, struct file *file, struct kstat *stat, u32 request_mask, unsigned int flags) { struct fuse_inode *fi = get_fuse_inode(inode); int err = 0; bool sync; if (flags & AT_STATX_FORCE_SYNC) sync = true; else if (flags & AT_STATX_DONT_SYNC) sync = false; else if (request_mask & READ_ONCE(fi->inval_mask)) sync = true; else sync = time_before64(fi->i_time, get_jiffies_64()); if (sync) { forget_all_cached_acls(inode); err = fuse_do_getattr(inode, stat, file); } else if (stat) { generic_fillattr(inode, stat); stat->mode = fi->orig_i_mode; stat->ino = fi->orig_ino; } return err; }
static int phuang_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { printk(KERN_DEBUG "%s", __func__); generic_fillattr(dentry->d_inode, stat); stat->nlink = 2; return 0; }
int fat_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct inode *inode = dentry->d_inode; generic_fillattr(inode, stat); stat->blksize = MSDOS_SB(inode->i_sb)->cluster_size; return 0; }
static int proc_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat ) { generic_fillattr(dentry->d_inode, stat); stat->nlink = proc_root.nlink + nr_processes(); return 0; }
int coda_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { int err = coda_revalidate_inode(dentry); if (!err) generic_fillattr(dentry->d_inode, stat); return err; }
static int nfs_namespace_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { if (NFS_FH(dentry->d_inode)->size != 0) return nfs_getattr(mnt, dentry, stat); generic_fillattr(dentry->d_inode, stat); return 0; }
int coda_getattr(const struct path *path, struct kstat *stat, u32 request_mask, unsigned int flags) { int err = coda_revalidate_inode(d_inode(path->dentry)); if (!err) generic_fillattr(d_inode(path->dentry), stat); return err; }
int f2fs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct inode *inode = dentry->d_inode; generic_fillattr(inode, stat); stat->blocks <<= 3; return 0; }
int simple_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct inode *inode = dentry->d_inode; generic_fillattr(inode, stat); stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9); return 0; }
int ext4_mod_dir_getattr(struct vfsmount *mnt, struct dentry *d, struct kstat *stat) { if (IS_EXT4_ACL_READY(dir_getattr)) { return DO_EXT4_ACL(dir_getattr, mnt, d, stat); } generic_fillattr(d->d_inode, stat); return 0; }
static int nfs_namespace_getattr(const struct path *path, struct kstat *stat, u32 request_mask, unsigned int query_flags) { if (NFS_FH(d_inode(path->dentry))->size != 0) return nfs_getattr(path, stat, request_mask, query_flags); generic_fillattr(d_inode(path->dentry), stat); return 0; }
/** * vfs_getattr_nosec - getattr without security checks * @path: file to get attributes from * @stat: structure to return attributes in * * Get attributes without calling security_inode_getattr. * * Currently the only caller other than vfs_getattr is internal to the * filehandle lookup code, which uses only the inode number and returns * no attributes to any user. Any other code probably wants * vfs_getattr. */ int vfs_getattr_nosec(struct path *path, struct kstat *stat) { struct inode *inode = d_backing_inode(path->dentry); if (inode->i_op->getattr) return inode->i_op->getattr(path->mnt, path->dentry, stat); generic_fillattr(inode, stat); return 0; }
int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { int err = cifs_revalidate(dentry); if (!err) { generic_fillattr(dentry->d_inode, stat); stat->blksize = CIFS_MAX_MSGSIZE; } return err; }
static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry, struct kstat *stat) { struct _inode *inode = d_get_inode(entry); int err = fuse_revalidate(entry); if (!err) generic_fillattr(inode, stat); return err; }
int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { generic_fillattr(dentry->d_inode, stat); if (INODE_VERSION(dentry->d_inode) == MINIX_V1) stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size); else stat->blocks = (BLOCK_SIZE / 512) * V2_minix_blocks(stat->size); stat->blksize = BLOCK_SIZE; return 0; }
int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct super_block *sb = dentry->d_sb; generic_fillattr(d_inode(dentry), stat); if (INODE_VERSION(d_inode(dentry)) == MINIX_V1) stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb); else stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb); stat->blksize = sb->s_blocksize; return 0; }
/** \<\<private\>\> Getattr function for VFS * @param *mnt - * @param *dentry - * @param count - size of buffer * @param *stat - pointer to kernel stat structure, which will be filled * * @return getattr return code */ static int proxyfs_fs_fdinode_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { unsigned long i_ino = dentry->d_inode->i_ino; int fd; fd = i_ino >> 16; mdbg(INFO3, "GETATTR fd: %d; i_ino: %08lx; stat: %p;", fd, i_ino, stat); generic_fillattr(dentry->d_inode, stat); return 0; }
static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry, struct kstat *stat) { struct inode *inode = entry->d_inode; int err = fuse_revalidate(entry); if (!err) /* FIXME: may want specialized function because of st_blksize on block devices on 2.6.19+ */ generic_fillattr(inode, stat); return err; }
int sf_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat) { int err; TRACE(); err = sf_inode_revalidate(dentry); if (err) return err; generic_fillattr(dentry->d_inode, kstat); return 0; }
int sysfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct sysfs_dirent *sd = dentry->d_fsdata; struct inode *inode = dentry->d_inode; mutex_lock(&sysfs_mutex); sysfs_refresh_inode(sd, inode); mutex_unlock(&sysfs_mutex); generic_fillattr(inode, stat); return 0; }
/* * read the attributes of an inode */ int afs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct inode *inode; inode = d_inode(dentry); _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation); generic_fillattr(inode, stat); return 0; }
static int sdcardfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct dentry *lower_dentry; struct inode *inode; struct inode *lower_inode; struct path lower_path; struct dentry *parent; struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb); struct sdcardfs_inode_info *info; parent = dget_parent(dentry); if(!check_caller_access_to_name(parent->d_inode, dentry->d_name.name, sbi->options.derive, 0, 0)) { printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n" " dentry: %s, task:%s\n", __func__, dentry->d_name.name, current->comm); dput(parent); return -EACCES; } dput(parent); inode = dentry->d_inode; sdcardfs_get_lower_path(dentry, &lower_path); lower_dentry = lower_path.dentry; lower_inode = sdcardfs_lower_inode(inode); info = SDCARDFS_I(inode); if (!strcmp(dentry->d_name.name, "ApkScript")) printk(KERN_ERR "dj enter_getattr_Apk--lower_inode->i_mode=%o, inode->i_mode=%o, info->d_mode=%o\n",lower_inode->i_mode, inode->i_mode, info->d_mode); if(!strcmp(dentry->d_name.name, "ShellScript")) printk(KERN_ERR "dj enter_getattr_Shell--lower_inode->i_mode=%o, inode->i_mode=%o, info->d_mode=%o\n",lower_inode->i_mode, inode->i_mode, info->d_mode); /* need to get inode->i_mutex */ mutex_lock(&inode->i_mutex); sdcardfs_copy_inode_attr(inode, lower_inode); fsstack_copy_inode_size(inode, lower_inode); /* if the dentry has been moved from other location * so, on this stage, its derived permission must be * rechecked from its private field. */ fix_derived_permission(inode); mutex_unlock(&inode->i_mutex); generic_fillattr(inode, stat); if (!strcmp(dentry->d_name.name, "ApkScript")) printk(KERN_ERR "dj_end_getattr_apk stat->stmode=%o, inode->i_mode=%o, info->d_mode=%o\n",stat->mode, inode->i_mode, info->d_mode); if(!strcmp(dentry->d_name.name, "ShellScript")) printk(KERN_ERR "dj_end_getattr_shell stat->stmode=%o, inode->i_mode=%o, info->d_mode=%o\n",stat->mode, inode->i_mode, info->d_mode); sdcardfs_put_lower_path(dentry, &lower_path); return 0; }
int kernfs_iop_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct kernfs_node *kn = dentry->d_fsdata; struct inode *inode = dentry->d_inode; mutex_lock(&kernfs_mutex); kernfs_refresh_inode(kn, inode); mutex_unlock(&kernfs_mutex); generic_fillattr(inode, stat); return 0; }
/* * read the attributes of an inode */ int afs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct inode *inode; inode = dentry->d_inode; _enter("{ ino=%lu v=%llu }", inode->i_ino, (unsigned long long)inode->i_version); generic_fillattr(inode, stat); return 0; }
int kernfs_iop_getattr(const struct path *path, struct kstat *stat, u32 request_mask, unsigned int query_flags) { struct inode *inode = d_inode(path->dentry); struct kernfs_node *kn = inode->i_private; mutex_lock(&kernfs_mutex); kernfs_refresh_inode(kn, inode); mutex_unlock(&kernfs_mutex); generic_fillattr(inode, stat); return 0; }
int hammerfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) { struct inode *inode; printk(KERN_INFO "hammerfs_getattr(ino=%lu, name=%s)\n", dentry->d_inode->i_ino, dentry->d_name.name); inode = dentry->d_inode; generic_fillattr(inode, stat); return 0; }
/** Obtain attributes of an object given a dentry */ int pvfs2_getattr( struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat) { int ret = -ENOENT; struct inode *inode = dentry->d_inode; pvfs2_inode_t *pvfs2_inode = NULL; gossip_debug(GOSSIP_INODE_DEBUG, "pvfs2_getattr: called on %s\n", dentry->d_name.name); /* This seems to be the only place to reliably detect mount options * parsed by the VFS layer. Propigate them to our internal sb structure so * that we can handle lazy time updates properly. */ #ifdef HAVE_MNT_NOATIME if(mnt->mnt_flags && MNT_NOATIME) { inode->i_sb->s_flags |= MS_NOATIME; } #endif #ifdef HAVE_MNT_NODIRATIME if(mnt->mnt_flags && MNT_NODIRATIME) { inode->i_sb->s_flags |= MS_NODIRATIME; } #endif /* * Similar to the above comment, a getattr also expects that all fields/attributes * of the inode would be refreshed. So again, we dont have too much of a choice * but refresh all the attributes. */ ret = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT); if (ret == 0) { generic_fillattr(inode, kstat); /* override block size reported to stat */ pvfs2_inode = PVFS2_I(inode); kstat->blksize = pvfs2_inode->blksize; } else { /* assume an I/O error and flag inode as bad */ gossip_debug(GOSSIP_INODE_DEBUG, "%s:%s:%d calling make bad inode\n", __FILE__, __func__, __LINE__); pvfs2_make_bad_inode(inode); } return ret; }