3 * Library for filesystems writers.
6 #include <linux/export.h>
7 #include <linux/pagemap.h>
8 #include <linux/slab.h>
9 #include <linux/mount.h>
10 #include <linux/vfs.h>
11 #include <linux/quotaops.h>
12 #include <linux/mutex.h>
13 #include <linux/exportfs.h>
14 #include <linux/writeback.h>
15 #include <linux/buffer_head.h> /* sync_mapping_buffers */
17 #include <asm/uaccess.h>
21 static inline int simple_positive(struct dentry *dentry)
23 return dentry->d_inode && !d_unhashed(dentry);
26 int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
29 struct inode *inode = dentry->d_inode;
30 generic_fillattr(inode, stat);
31 stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9);
34 EXPORT_SYMBOL(simple_getattr);
36 int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
38 buf->f_type = dentry->d_sb->s_magic;
39 buf->f_bsize = PAGE_CACHE_SIZE;
40 buf->f_namelen = NAME_MAX;
43 EXPORT_SYMBOL(simple_statfs);
46 * Retaining negative dentries for an in-memory filesystem just wastes
47 * memory and lookup time: arrange for them to be deleted immediately.
49 static int simple_delete_dentry(const struct dentry *dentry)
55 * Lookup the data. This is trivial - if the dentry didn't already
56 * exist, we know it is negative. Set d_op to delete negative dentries.
58 struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
60 static const struct dentry_operations simple_dentry_operations = {
61 .d_delete = simple_delete_dentry,
64 if (dentry->d_name.len > NAME_MAX)
65 return ERR_PTR(-ENAMETOOLONG);
66 if (!dentry->d_sb->s_d_op)
67 d_set_d_op(dentry, &simple_dentry_operations);
71 EXPORT_SYMBOL(simple_lookup);
73 int dcache_dir_open(struct inode *inode, struct file *file)
75 static struct qstr cursor_name = QSTR_INIT(".", 1);
77 file->private_data = d_alloc(file->f_path.dentry, &cursor_name);
79 return file->private_data ? 0 : -ENOMEM;
81 EXPORT_SYMBOL(dcache_dir_open);
83 int dcache_dir_close(struct inode *inode, struct file *file)
85 dput(file->private_data);
88 EXPORT_SYMBOL(dcache_dir_close);
90 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
92 struct dentry *dentry = file->f_path.dentry;
93 mutex_lock(&dentry->d_inode->i_mutex);
96 offset += file->f_pos;
101 mutex_unlock(&dentry->d_inode->i_mutex);
104 if (offset != file->f_pos) {
105 file->f_pos = offset;
106 if (file->f_pos >= 2) {
108 struct dentry *cursor = file->private_data;
109 loff_t n = file->f_pos - 2;
111 spin_lock(&dentry->d_lock);
112 /* d_lock not required for cursor */
113 list_del(&cursor->d_u.d_child);
114 p = dentry->d_subdirs.next;
115 while (n && p != &dentry->d_subdirs) {
117 next = list_entry(p, struct dentry, d_u.d_child);
118 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
119 if (simple_positive(next))
121 spin_unlock(&next->d_lock);
124 list_add_tail(&cursor->d_u.d_child, p);
125 spin_unlock(&dentry->d_lock);
128 mutex_unlock(&dentry->d_inode->i_mutex);
131 EXPORT_SYMBOL(dcache_dir_lseek);
133 /* Relationship between i_mode and the DT_xxx types */
134 static inline unsigned char dt_type(struct inode *inode)
136 return (inode->i_mode >> 12) & 15;
140 * Directory is locked and all positive dentries in it are safe, since
141 * for ramfs-type trees they can't go away without unlink() or rmdir(),
142 * both impossible due to the lock on directory.
145 int dcache_readdir(struct file *file, struct dir_context *ctx)
147 struct dentry *dentry = file->f_path.dentry;
148 struct dentry *cursor = file->private_data;
149 struct list_head *p, *q = &cursor->d_u.d_child;
151 if (!dir_emit_dots(file, ctx))
153 spin_lock(&dentry->d_lock);
155 list_move(q, &dentry->d_subdirs);
157 for (p = q->next; p != &dentry->d_subdirs; p = p->next) {
158 struct dentry *next = list_entry(p, struct dentry, d_u.d_child);
159 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
160 if (!simple_positive(next)) {
161 spin_unlock(&next->d_lock);
165 spin_unlock(&next->d_lock);
166 spin_unlock(&dentry->d_lock);
167 if (!dir_emit(ctx, next->d_name.name, next->d_name.len,
168 next->d_inode->i_ino, dt_type(next->d_inode)))
170 spin_lock(&dentry->d_lock);
171 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
172 /* next is still alive */
174 spin_unlock(&next->d_lock);
178 spin_unlock(&dentry->d_lock);
181 EXPORT_SYMBOL(dcache_readdir);
183 ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
187 EXPORT_SYMBOL(generic_read_dir);
189 const struct file_operations simple_dir_operations = {
190 .open = dcache_dir_open,
191 .release = dcache_dir_close,
192 .llseek = dcache_dir_lseek,
193 .read = generic_read_dir,
194 .iterate = dcache_readdir,
197 EXPORT_SYMBOL(simple_dir_operations);
199 const struct inode_operations simple_dir_inode_operations = {
200 .lookup = simple_lookup,
202 EXPORT_SYMBOL(simple_dir_inode_operations);
204 static const struct super_operations simple_super_operations = {
205 .statfs = simple_statfs,
209 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
210 * will never be mountable)
212 struct dentry *mount_pseudo(struct file_system_type *fs_type, char *name,
213 const struct super_operations *ops,
214 const struct dentry_operations *dops, unsigned long magic)
216 struct super_block *s;
217 struct dentry *dentry;
219 struct qstr d_name = QSTR_INIT(name, strlen(name));
221 s = sget(fs_type, NULL, set_anon_super, MS_NOUSER, NULL);
225 s->s_maxbytes = MAX_LFS_FILESIZE;
226 s->s_blocksize = PAGE_SIZE;
227 s->s_blocksize_bits = PAGE_SHIFT;
229 s->s_op = ops ? ops : &simple_super_operations;
235 * since this is the first inode, make it number 1. New inodes created
236 * after this must take care not to collide with it (by passing
237 * max_reserved of 1 to iunique).
240 root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
241 root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
242 dentry = __d_alloc(s, &d_name);
247 d_instantiate(dentry, root);
250 s->s_flags |= MS_ACTIVE;
251 return dget(s->s_root);
254 deactivate_locked_super(s);
255 return ERR_PTR(-ENOMEM);
257 EXPORT_SYMBOL(mount_pseudo);
259 int simple_open(struct inode *inode, struct file *file)
261 if (inode->i_private)
262 file->private_data = inode->i_private;
265 EXPORT_SYMBOL(simple_open);
267 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
269 struct inode *inode = old_dentry->d_inode;
271 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
275 d_instantiate(dentry, inode);
278 EXPORT_SYMBOL(simple_link);
280 int simple_empty(struct dentry *dentry)
282 struct dentry *child;
285 spin_lock(&dentry->d_lock);
286 list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) {
287 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
288 if (simple_positive(child)) {
289 spin_unlock(&child->d_lock);
292 spin_unlock(&child->d_lock);
296 spin_unlock(&dentry->d_lock);
299 EXPORT_SYMBOL(simple_empty);
301 int simple_unlink(struct inode *dir, struct dentry *dentry)
303 struct inode *inode = dentry->d_inode;
305 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
310 EXPORT_SYMBOL(simple_unlink);
312 int simple_rmdir(struct inode *dir, struct dentry *dentry)
314 if (!simple_empty(dentry))
317 drop_nlink(dentry->d_inode);
318 simple_unlink(dir, dentry);
322 EXPORT_SYMBOL(simple_rmdir);
324 int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
325 struct inode *new_dir, struct dentry *new_dentry)
327 struct inode *inode = old_dentry->d_inode;
328 int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode);
330 if (!simple_empty(new_dentry))
333 if (new_dentry->d_inode) {
334 simple_unlink(new_dir, new_dentry);
336 drop_nlink(new_dentry->d_inode);
339 } else if (they_are_dirs) {
344 old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
345 new_dir->i_mtime = inode->i_ctime = CURRENT_TIME;
349 EXPORT_SYMBOL(simple_rename);
352 * simple_setattr - setattr for simple filesystem
354 * @iattr: iattr structure
356 * Returns 0 on success, -error on failure.
358 * simple_setattr is a simple ->setattr implementation without a proper
359 * implementation of size changes.
361 * It can either be used for in-memory filesystems or special files
362 * on simple regular filesystems. Anything that needs to change on-disk
363 * or wire state on size changes needs its own setattr method.
365 int simple_setattr(struct dentry *dentry, struct iattr *iattr)
367 struct inode *inode = dentry->d_inode;
370 error = inode_change_ok(inode, iattr);
374 if (iattr->ia_valid & ATTR_SIZE)
375 truncate_setsize(inode, iattr->ia_size);
376 setattr_copy(inode, iattr);
377 mark_inode_dirty(inode);
380 EXPORT_SYMBOL(simple_setattr);
382 int simple_readpage(struct file *file, struct page *page)
384 clear_highpage(page);
385 flush_dcache_page(page);
386 SetPageUptodate(page);
390 EXPORT_SYMBOL(simple_readpage);
392 int simple_write_begin(struct file *file, struct address_space *mapping,
393 loff_t pos, unsigned len, unsigned flags,
394 struct page **pagep, void **fsdata)
399 index = pos >> PAGE_CACHE_SHIFT;
401 page = grab_cache_page_write_begin(mapping, index, flags);
407 if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) {
408 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
410 zero_user_segments(page, 0, from, from + len, PAGE_CACHE_SIZE);
414 EXPORT_SYMBOL(simple_write_begin);
417 * simple_write_end - .write_end helper for non-block-device FSes
418 * @available: See .write_end of address_space_operations
427 * simple_write_end does the minimum needed for updating a page after writing is
428 * done. It has the same API signature as the .write_end of
429 * address_space_operations vector. So it can just be set onto .write_end for
430 * FSes that don't need any other processing. i_mutex is assumed to be held.
431 * Block based filesystems should use generic_write_end().
432 * NOTE: Even though i_size might get updated by this function, mark_inode_dirty
433 * is not called, so a filesystem that actually does store data in .write_inode
434 * should extend on what's done here with a call to mark_inode_dirty() in the
435 * case that i_size has changed.
437 int simple_write_end(struct file *file, struct address_space *mapping,
438 loff_t pos, unsigned len, unsigned copied,
439 struct page *page, void *fsdata)
441 struct inode *inode = page->mapping->host;
442 loff_t last_pos = pos + copied;
444 /* zero the stale part of the page if we did a short copy */
446 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
448 zero_user(page, from + copied, len - copied);
451 if (!PageUptodate(page))
452 SetPageUptodate(page);
454 * No need to use i_size_read() here, the i_size
455 * cannot change under us because we hold the i_mutex.
457 if (last_pos > inode->i_size)
458 i_size_write(inode, last_pos);
460 set_page_dirty(page);
462 page_cache_release(page);
466 EXPORT_SYMBOL(simple_write_end);
469 * the inodes created here are not hashed. If you use iunique to generate
470 * unique inode values later for this filesystem, then you must take care
471 * to pass it an appropriate max_reserved value to avoid collisions.
473 int simple_fill_super(struct super_block *s, unsigned long magic,
474 struct tree_descr *files)
478 struct dentry *dentry;
481 s->s_blocksize = PAGE_CACHE_SIZE;
482 s->s_blocksize_bits = PAGE_CACHE_SHIFT;
484 s->s_op = &simple_super_operations;
487 inode = new_inode(s);
491 * because the root inode is 1, the files array must not contain an
495 inode->i_mode = S_IFDIR | 0755;
496 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
497 inode->i_op = &simple_dir_inode_operations;
498 inode->i_fop = &simple_dir_operations;
500 root = d_make_root(inode);
503 for (i = 0; !files->name || files->name[0]; i++, files++) {
507 /* warn if it tries to conflict with the root inode */
508 if (unlikely(i == 1))
509 printk(KERN_WARNING "%s: %s passed in a files array"
510 "with an index of 1!\n", __func__,
513 dentry = d_alloc_name(root, files->name);
516 inode = new_inode(s);
521 inode->i_mode = S_IFREG | files->mode;
522 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
523 inode->i_fop = files->ops;
525 d_add(dentry, inode);
531 shrink_dcache_parent(root);
535 EXPORT_SYMBOL(simple_fill_super);
537 static DEFINE_SPINLOCK(pin_fs_lock);
539 int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
541 struct vfsmount *mnt = NULL;
542 spin_lock(&pin_fs_lock);
543 if (unlikely(!*mount)) {
544 spin_unlock(&pin_fs_lock);
545 mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, NULL);
548 spin_lock(&pin_fs_lock);
554 spin_unlock(&pin_fs_lock);
558 EXPORT_SYMBOL(simple_pin_fs);
560 void simple_release_fs(struct vfsmount **mount, int *count)
562 struct vfsmount *mnt;
563 spin_lock(&pin_fs_lock);
567 spin_unlock(&pin_fs_lock);
570 EXPORT_SYMBOL(simple_release_fs);
573 * simple_read_from_buffer - copy data from the buffer to user space
574 * @to: the user space buffer to read to
575 * @count: the maximum number of bytes to read
576 * @ppos: the current position in the buffer
577 * @from: the buffer to read from
578 * @available: the size of the buffer
580 * The simple_read_from_buffer() function reads up to @count bytes from the
581 * buffer @from at offset @ppos into the user space address starting at @to.
583 * On success, the number of bytes read is returned and the offset @ppos is
584 * advanced by this number, or negative value is returned on error.
586 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
587 const void *from, size_t available)
594 if (pos >= available || !count)
596 if (count > available - pos)
597 count = available - pos;
598 ret = copy_to_user(to, from + pos, count);
605 EXPORT_SYMBOL(simple_read_from_buffer);
608 * simple_write_to_buffer - copy data from user space to the buffer
609 * @to: the buffer to write to
610 * @available: the size of the buffer
611 * @ppos: the current position in the buffer
612 * @from: the user space buffer to read from
613 * @count: the maximum number of bytes to read
615 * The simple_write_to_buffer() function reads up to @count bytes from the user
616 * space address starting at @from into the buffer @to at offset @ppos.
618 * On success, the number of bytes written is returned and the offset @ppos is
619 * advanced by this number, or negative value is returned on error.
621 ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
622 const void __user *from, size_t count)
629 if (pos >= available || !count)
631 if (count > available - pos)
632 count = available - pos;
633 res = copy_from_user(to + pos, from, count);
640 EXPORT_SYMBOL(simple_write_to_buffer);
643 * memory_read_from_buffer - copy data from the buffer
644 * @to: the kernel space buffer to read to
645 * @count: the maximum number of bytes to read
646 * @ppos: the current position in the buffer
647 * @from: the buffer to read from
648 * @available: the size of the buffer
650 * The memory_read_from_buffer() function reads up to @count bytes from the
651 * buffer @from at offset @ppos into the kernel space address starting at @to.
653 * On success, the number of bytes read is returned and the offset @ppos is
654 * advanced by this number, or negative value is returned on error.
656 ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
657 const void *from, size_t available)
663 if (pos >= available)
665 if (count > available - pos)
666 count = available - pos;
667 memcpy(to, from + pos, count);
672 EXPORT_SYMBOL(memory_read_from_buffer);
675 * Transaction based IO.
676 * The file expects a single write which triggers the transaction, and then
677 * possibly a read which collects the result - which is stored in a
681 void simple_transaction_set(struct file *file, size_t n)
683 struct simple_transaction_argresp *ar = file->private_data;
685 BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
688 * The barrier ensures that ar->size will really remain zero until
689 * ar->data is ready for reading.
694 EXPORT_SYMBOL(simple_transaction_set);
696 char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
698 struct simple_transaction_argresp *ar;
699 static DEFINE_SPINLOCK(simple_transaction_lock);
701 if (size > SIMPLE_TRANSACTION_LIMIT - 1)
702 return ERR_PTR(-EFBIG);
704 ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
706 return ERR_PTR(-ENOMEM);
708 spin_lock(&simple_transaction_lock);
710 /* only one write allowed per open */
711 if (file->private_data) {
712 spin_unlock(&simple_transaction_lock);
713 free_page((unsigned long)ar);
714 return ERR_PTR(-EBUSY);
717 file->private_data = ar;
719 spin_unlock(&simple_transaction_lock);
721 if (copy_from_user(ar->data, buf, size))
722 return ERR_PTR(-EFAULT);
726 EXPORT_SYMBOL(simple_transaction_get);
728 ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
730 struct simple_transaction_argresp *ar = file->private_data;
734 return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
736 EXPORT_SYMBOL(simple_transaction_read);
738 int simple_transaction_release(struct inode *inode, struct file *file)
740 free_page((unsigned long)file->private_data);
743 EXPORT_SYMBOL(simple_transaction_release);
745 /* Simple attribute files */
748 int (*get)(void *, u64 *);
749 int (*set)(void *, u64);
750 char get_buf[24]; /* enough to store a u64 and "\n\0" */
753 const char *fmt; /* format for read operation */
754 struct mutex mutex; /* protects access to these buffers */
757 /* simple_attr_open is called by an actual attribute open file operation
758 * to set the attribute specific access operations. */
759 int simple_attr_open(struct inode *inode, struct file *file,
760 int (*get)(void *, u64 *), int (*set)(void *, u64),
763 struct simple_attr *attr;
765 attr = kmalloc(sizeof(*attr), GFP_KERNEL);
771 attr->data = inode->i_private;
773 mutex_init(&attr->mutex);
775 file->private_data = attr;
777 return nonseekable_open(inode, file);
779 EXPORT_SYMBOL_GPL(simple_attr_open);
781 int simple_attr_release(struct inode *inode, struct file *file)
783 kfree(file->private_data);
786 EXPORT_SYMBOL_GPL(simple_attr_release); /* GPL-only? This? Really? */
788 /* read from the buffer that is filled with the get function */
789 ssize_t simple_attr_read(struct file *file, char __user *buf,
790 size_t len, loff_t *ppos)
792 struct simple_attr *attr;
796 attr = file->private_data;
801 ret = mutex_lock_interruptible(&attr->mutex);
805 if (*ppos) { /* continued read */
806 size = strlen(attr->get_buf);
807 } else { /* first read */
809 ret = attr->get(attr->data, &val);
813 size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
814 attr->fmt, (unsigned long long)val);
817 ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
819 mutex_unlock(&attr->mutex);
822 EXPORT_SYMBOL_GPL(simple_attr_read);
824 /* interpret the buffer as a number to call the set function with */
825 ssize_t simple_attr_write(struct file *file, const char __user *buf,
826 size_t len, loff_t *ppos)
828 struct simple_attr *attr;
833 attr = file->private_data;
837 ret = mutex_lock_interruptible(&attr->mutex);
842 size = min(sizeof(attr->set_buf) - 1, len);
843 if (copy_from_user(attr->set_buf, buf, size))
846 attr->set_buf[size] = '\0';
847 val = simple_strtoll(attr->set_buf, NULL, 0);
848 ret = attr->set(attr->data, val);
850 ret = len; /* on success, claim we got the whole input */
852 mutex_unlock(&attr->mutex);
855 EXPORT_SYMBOL_GPL(simple_attr_write);
858 * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
859 * @sb: filesystem to do the file handle conversion on
860 * @fid: file handle to convert
861 * @fh_len: length of the file handle in bytes
862 * @fh_type: type of file handle
863 * @get_inode: filesystem callback to retrieve inode
865 * This function decodes @fid as long as it has one of the well-known
866 * Linux filehandle types and calls @get_inode on it to retrieve the
867 * inode for the object specified in the file handle.
869 struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid,
870 int fh_len, int fh_type, struct inode *(*get_inode)
871 (struct super_block *sb, u64 ino, u32 gen))
873 struct inode *inode = NULL;
879 case FILEID_INO32_GEN:
880 case FILEID_INO32_GEN_PARENT:
881 inode = get_inode(sb, fid->i32.ino, fid->i32.gen);
885 return d_obtain_alias(inode);
887 EXPORT_SYMBOL_GPL(generic_fh_to_dentry);
890 * generic_fh_to_parent - generic helper for the fh_to_parent export operation
891 * @sb: filesystem to do the file handle conversion on
892 * @fid: file handle to convert
893 * @fh_len: length of the file handle in bytes
894 * @fh_type: type of file handle
895 * @get_inode: filesystem callback to retrieve inode
897 * This function decodes @fid as long as it has one of the well-known
898 * Linux filehandle types and calls @get_inode on it to retrieve the
899 * inode for the _parent_ object specified in the file handle if it
900 * is specified in the file handle, or NULL otherwise.
902 struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid,
903 int fh_len, int fh_type, struct inode *(*get_inode)
904 (struct super_block *sb, u64 ino, u32 gen))
906 struct inode *inode = NULL;
912 case FILEID_INO32_GEN_PARENT:
913 inode = get_inode(sb, fid->i32.parent_ino,
914 (fh_len > 3 ? fid->i32.parent_gen : 0));
918 return d_obtain_alias(inode);
920 EXPORT_SYMBOL_GPL(generic_fh_to_parent);
923 * generic_file_fsync - generic fsync implementation for simple filesystems
924 * @file: file to synchronize
925 * @datasync: only synchronize essential metadata if true
927 * This is a generic implementation of the fsync method for simple
928 * filesystems which track all non-inode metadata in the buffers list
929 * hanging off the address_space structure.
931 int generic_file_fsync(struct file *file, loff_t start, loff_t end,
934 struct inode *inode = file->f_mapping->host;
938 err = filemap_write_and_wait_range(inode->i_mapping, start, end);
942 mutex_lock(&inode->i_mutex);
943 ret = sync_mapping_buffers(inode->i_mapping);
944 if (!(inode->i_state & I_DIRTY))
946 if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
949 err = sync_inode_metadata(inode, 1);
953 mutex_unlock(&inode->i_mutex);
956 EXPORT_SYMBOL(generic_file_fsync);
959 * generic_check_addressable - Check addressability of file system
960 * @blocksize_bits: log of file system block size
961 * @num_blocks: number of blocks in file system
963 * Determine whether a file system with @num_blocks blocks (and a
964 * block size of 2**@blocksize_bits) is addressable by the sector_t
965 * and page cache of the system. Return 0 if so and -EFBIG otherwise.
967 int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks)
969 u64 last_fs_block = num_blocks - 1;
971 last_fs_block >> (PAGE_CACHE_SHIFT - blocksize_bits);
973 if (unlikely(num_blocks == 0))
976 if ((blocksize_bits < 9) || (blocksize_bits > PAGE_CACHE_SHIFT))
979 if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) ||
980 (last_fs_page > (pgoff_t)(~0ULL))) {
985 EXPORT_SYMBOL(generic_check_addressable);
988 * No-op implementation of ->fsync for in-memory filesystems.
990 int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync)
994 EXPORT_SYMBOL(noop_fsync);