xref: /openbmc/linux/fs/libfs.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  *	fs/libfs.c
3  *	Library for filesystems writers.
4  */
5 
6 #include <linux/module.h>
7 #include <linux/pagemap.h>
8 #include <linux/mount.h>
9 #include <linux/vfs.h>
10 #include <asm/uaccess.h>
11 
12 int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
13 		   struct kstat *stat)
14 {
15 	struct inode *inode = dentry->d_inode;
16 	generic_fillattr(inode, stat);
17 	stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9);
18 	return 0;
19 }
20 
21 int simple_statfs(struct super_block *sb, struct kstatfs *buf)
22 {
23 	buf->f_type = sb->s_magic;
24 	buf->f_bsize = PAGE_CACHE_SIZE;
25 	buf->f_namelen = NAME_MAX;
26 	return 0;
27 }
28 
29 /*
30  * Retaining negative dentries for an in-memory filesystem just wastes
31  * memory and lookup time: arrange for them to be deleted immediately.
32  */
33 static int simple_delete_dentry(struct dentry *dentry)
34 {
35 	return 1;
36 }
37 
38 /*
39  * Lookup the data. This is trivial - if the dentry didn't already
40  * exist, we know it is negative.  Set d_op to delete negative dentries.
41  */
42 struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
43 {
44 	static struct dentry_operations simple_dentry_operations = {
45 		.d_delete = simple_delete_dentry,
46 	};
47 
48 	if (dentry->d_name.len > NAME_MAX)
49 		return ERR_PTR(-ENAMETOOLONG);
50 	dentry->d_op = &simple_dentry_operations;
51 	d_add(dentry, NULL);
52 	return NULL;
53 }
54 
55 int simple_sync_file(struct file * file, struct dentry *dentry, int datasync)
56 {
57 	return 0;
58 }
59 
60 int dcache_dir_open(struct inode *inode, struct file *file)
61 {
62 	static struct qstr cursor_name = {.len = 1, .name = "."};
63 
64 	file->private_data = d_alloc(file->f_dentry, &cursor_name);
65 
66 	return file->private_data ? 0 : -ENOMEM;
67 }
68 
69 int dcache_dir_close(struct inode *inode, struct file *file)
70 {
71 	dput(file->private_data);
72 	return 0;
73 }
74 
75 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
76 {
77 	down(&file->f_dentry->d_inode->i_sem);
78 	switch (origin) {
79 		case 1:
80 			offset += file->f_pos;
81 		case 0:
82 			if (offset >= 0)
83 				break;
84 		default:
85 			up(&file->f_dentry->d_inode->i_sem);
86 			return -EINVAL;
87 	}
88 	if (offset != file->f_pos) {
89 		file->f_pos = offset;
90 		if (file->f_pos >= 2) {
91 			struct list_head *p;
92 			struct dentry *cursor = file->private_data;
93 			loff_t n = file->f_pos - 2;
94 
95 			spin_lock(&dcache_lock);
96 			list_del(&cursor->d_child);
97 			p = file->f_dentry->d_subdirs.next;
98 			while (n && p != &file->f_dentry->d_subdirs) {
99 				struct dentry *next;
100 				next = list_entry(p, struct dentry, d_child);
101 				if (!d_unhashed(next) && next->d_inode)
102 					n--;
103 				p = p->next;
104 			}
105 			list_add_tail(&cursor->d_child, p);
106 			spin_unlock(&dcache_lock);
107 		}
108 	}
109 	up(&file->f_dentry->d_inode->i_sem);
110 	return offset;
111 }
112 
113 /* Relationship between i_mode and the DT_xxx types */
114 static inline unsigned char dt_type(struct inode *inode)
115 {
116 	return (inode->i_mode >> 12) & 15;
117 }
118 
119 /*
120  * Directory is locked and all positive dentries in it are safe, since
121  * for ramfs-type trees they can't go away without unlink() or rmdir(),
122  * both impossible due to the lock on directory.
123  */
124 
125 int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
126 {
127 	struct dentry *dentry = filp->f_dentry;
128 	struct dentry *cursor = filp->private_data;
129 	struct list_head *p, *q = &cursor->d_child;
130 	ino_t ino;
131 	int i = filp->f_pos;
132 
133 	switch (i) {
134 		case 0:
135 			ino = dentry->d_inode->i_ino;
136 			if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
137 				break;
138 			filp->f_pos++;
139 			i++;
140 			/* fallthrough */
141 		case 1:
142 			ino = parent_ino(dentry);
143 			if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
144 				break;
145 			filp->f_pos++;
146 			i++;
147 			/* fallthrough */
148 		default:
149 			spin_lock(&dcache_lock);
150 			if (filp->f_pos == 2) {
151 				list_del(q);
152 				list_add(q, &dentry->d_subdirs);
153 			}
154 			for (p=q->next; p != &dentry->d_subdirs; p=p->next) {
155 				struct dentry *next;
156 				next = list_entry(p, struct dentry, d_child);
157 				if (d_unhashed(next) || !next->d_inode)
158 					continue;
159 
160 				spin_unlock(&dcache_lock);
161 				if (filldir(dirent, next->d_name.name, next->d_name.len, filp->f_pos, next->d_inode->i_ino, dt_type(next->d_inode)) < 0)
162 					return 0;
163 				spin_lock(&dcache_lock);
164 				/* next is still alive */
165 				list_del(q);
166 				list_add(q, p);
167 				p = q;
168 				filp->f_pos++;
169 			}
170 			spin_unlock(&dcache_lock);
171 	}
172 	return 0;
173 }
174 
175 ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
176 {
177 	return -EISDIR;
178 }
179 
180 struct file_operations simple_dir_operations = {
181 	.open		= dcache_dir_open,
182 	.release	= dcache_dir_close,
183 	.llseek		= dcache_dir_lseek,
184 	.read		= generic_read_dir,
185 	.readdir	= dcache_readdir,
186 	.fsync		= simple_sync_file,
187 };
188 
189 struct inode_operations simple_dir_inode_operations = {
190 	.lookup		= simple_lookup,
191 };
192 
193 /*
194  * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
195  * will never be mountable)
196  */
197 struct super_block *
198 get_sb_pseudo(struct file_system_type *fs_type, char *name,
199 	struct super_operations *ops, unsigned long magic)
200 {
201 	struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
202 	static struct super_operations default_ops = {.statfs = simple_statfs};
203 	struct dentry *dentry;
204 	struct inode *root;
205 	struct qstr d_name = {.name = name, .len = strlen(name)};
206 
207 	if (IS_ERR(s))
208 		return s;
209 
210 	s->s_flags = MS_NOUSER;
211 	s->s_maxbytes = ~0ULL;
212 	s->s_blocksize = 1024;
213 	s->s_blocksize_bits = 10;
214 	s->s_magic = magic;
215 	s->s_op = ops ? ops : &default_ops;
216 	s->s_time_gran = 1;
217 	root = new_inode(s);
218 	if (!root)
219 		goto Enomem;
220 	root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
221 	root->i_uid = root->i_gid = 0;
222 	root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
223 	dentry = d_alloc(NULL, &d_name);
224 	if (!dentry) {
225 		iput(root);
226 		goto Enomem;
227 	}
228 	dentry->d_sb = s;
229 	dentry->d_parent = dentry;
230 	d_instantiate(dentry, root);
231 	s->s_root = dentry;
232 	s->s_flags |= MS_ACTIVE;
233 	return s;
234 
235 Enomem:
236 	up_write(&s->s_umount);
237 	deactivate_super(s);
238 	return ERR_PTR(-ENOMEM);
239 }
240 
241 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
242 {
243 	struct inode *inode = old_dentry->d_inode;
244 
245 	inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
246 	inode->i_nlink++;
247 	atomic_inc(&inode->i_count);
248 	dget(dentry);
249 	d_instantiate(dentry, inode);
250 	return 0;
251 }
252 
253 static inline int simple_positive(struct dentry *dentry)
254 {
255 	return dentry->d_inode && !d_unhashed(dentry);
256 }
257 
258 int simple_empty(struct dentry *dentry)
259 {
260 	struct dentry *child;
261 	int ret = 0;
262 
263 	spin_lock(&dcache_lock);
264 	list_for_each_entry(child, &dentry->d_subdirs, d_child)
265 		if (simple_positive(child))
266 			goto out;
267 	ret = 1;
268 out:
269 	spin_unlock(&dcache_lock);
270 	return ret;
271 }
272 
273 int simple_unlink(struct inode *dir, struct dentry *dentry)
274 {
275 	struct inode *inode = dentry->d_inode;
276 
277 	inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
278 	inode->i_nlink--;
279 	dput(dentry);
280 	return 0;
281 }
282 
283 int simple_rmdir(struct inode *dir, struct dentry *dentry)
284 {
285 	if (!simple_empty(dentry))
286 		return -ENOTEMPTY;
287 
288 	dentry->d_inode->i_nlink--;
289 	simple_unlink(dir, dentry);
290 	dir->i_nlink--;
291 	return 0;
292 }
293 
294 int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
295 		struct inode *new_dir, struct dentry *new_dentry)
296 {
297 	struct inode *inode = old_dentry->d_inode;
298 	int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode);
299 
300 	if (!simple_empty(new_dentry))
301 		return -ENOTEMPTY;
302 
303 	if (new_dentry->d_inode) {
304 		simple_unlink(new_dir, new_dentry);
305 		if (they_are_dirs)
306 			old_dir->i_nlink--;
307 	} else if (they_are_dirs) {
308 		old_dir->i_nlink--;
309 		new_dir->i_nlink++;
310 	}
311 
312 	old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
313 		new_dir->i_mtime = inode->i_ctime = CURRENT_TIME;
314 
315 	return 0;
316 }
317 
318 int simple_readpage(struct file *file, struct page *page)
319 {
320 	void *kaddr;
321 
322 	if (PageUptodate(page))
323 		goto out;
324 
325 	kaddr = kmap_atomic(page, KM_USER0);
326 	memset(kaddr, 0, PAGE_CACHE_SIZE);
327 	kunmap_atomic(kaddr, KM_USER0);
328 	flush_dcache_page(page);
329 	SetPageUptodate(page);
330 out:
331 	unlock_page(page);
332 	return 0;
333 }
334 
335 int simple_prepare_write(struct file *file, struct page *page,
336 			unsigned from, unsigned to)
337 {
338 	if (!PageUptodate(page)) {
339 		if (to - from != PAGE_CACHE_SIZE) {
340 			void *kaddr = kmap_atomic(page, KM_USER0);
341 			memset(kaddr, 0, from);
342 			memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
343 			flush_dcache_page(page);
344 			kunmap_atomic(kaddr, KM_USER0);
345 		}
346 		SetPageUptodate(page);
347 	}
348 	return 0;
349 }
350 
351 int simple_commit_write(struct file *file, struct page *page,
352 			unsigned offset, unsigned to)
353 {
354 	struct inode *inode = page->mapping->host;
355 	loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
356 
357 	/*
358 	 * No need to use i_size_read() here, the i_size
359 	 * cannot change under us because we hold the i_sem.
360 	 */
361 	if (pos > inode->i_size)
362 		i_size_write(inode, pos);
363 	set_page_dirty(page);
364 	return 0;
365 }
366 
367 int simple_fill_super(struct super_block *s, int magic, struct tree_descr *files)
368 {
369 	static struct super_operations s_ops = {.statfs = simple_statfs};
370 	struct inode *inode;
371 	struct dentry *root;
372 	struct dentry *dentry;
373 	int i;
374 
375 	s->s_blocksize = PAGE_CACHE_SIZE;
376 	s->s_blocksize_bits = PAGE_CACHE_SHIFT;
377 	s->s_magic = magic;
378 	s->s_op = &s_ops;
379 	s->s_time_gran = 1;
380 
381 	inode = new_inode(s);
382 	if (!inode)
383 		return -ENOMEM;
384 	inode->i_mode = S_IFDIR | 0755;
385 	inode->i_uid = inode->i_gid = 0;
386 	inode->i_blksize = PAGE_CACHE_SIZE;
387 	inode->i_blocks = 0;
388 	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
389 	inode->i_op = &simple_dir_inode_operations;
390 	inode->i_fop = &simple_dir_operations;
391 	root = d_alloc_root(inode);
392 	if (!root) {
393 		iput(inode);
394 		return -ENOMEM;
395 	}
396 	for (i = 0; !files->name || files->name[0]; i++, files++) {
397 		if (!files->name)
398 			continue;
399 		dentry = d_alloc_name(root, files->name);
400 		if (!dentry)
401 			goto out;
402 		inode = new_inode(s);
403 		if (!inode)
404 			goto out;
405 		inode->i_mode = S_IFREG | files->mode;
406 		inode->i_uid = inode->i_gid = 0;
407 		inode->i_blksize = PAGE_CACHE_SIZE;
408 		inode->i_blocks = 0;
409 		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
410 		inode->i_fop = files->ops;
411 		inode->i_ino = i;
412 		d_add(dentry, inode);
413 	}
414 	s->s_root = root;
415 	return 0;
416 out:
417 	d_genocide(root);
418 	dput(root);
419 	return -ENOMEM;
420 }
421 
422 static DEFINE_SPINLOCK(pin_fs_lock);
423 
424 int simple_pin_fs(char *name, struct vfsmount **mount, int *count)
425 {
426 	struct vfsmount *mnt = NULL;
427 	spin_lock(&pin_fs_lock);
428 	if (unlikely(!*mount)) {
429 		spin_unlock(&pin_fs_lock);
430 		mnt = do_kern_mount(name, 0, name, NULL);
431 		if (IS_ERR(mnt))
432 			return PTR_ERR(mnt);
433 		spin_lock(&pin_fs_lock);
434 		if (!*mount)
435 			*mount = mnt;
436 	}
437 	mntget(*mount);
438 	++*count;
439 	spin_unlock(&pin_fs_lock);
440 	mntput(mnt);
441 	return 0;
442 }
443 
444 void simple_release_fs(struct vfsmount **mount, int *count)
445 {
446 	struct vfsmount *mnt;
447 	spin_lock(&pin_fs_lock);
448 	mnt = *mount;
449 	if (!--*count)
450 		*mount = NULL;
451 	spin_unlock(&pin_fs_lock);
452 	mntput(mnt);
453 }
454 
455 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
456 				const void *from, size_t available)
457 {
458 	loff_t pos = *ppos;
459 	if (pos < 0)
460 		return -EINVAL;
461 	if (pos >= available)
462 		return 0;
463 	if (count > available - pos)
464 		count = available - pos;
465 	if (copy_to_user(to, from + pos, count))
466 		return -EFAULT;
467 	*ppos = pos + count;
468 	return count;
469 }
470 
471 /*
472  * Transaction based IO.
473  * The file expects a single write which triggers the transaction, and then
474  * possibly a read which collects the result - which is stored in a
475  * file-local buffer.
476  */
477 char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
478 {
479 	struct simple_transaction_argresp *ar;
480 	static DEFINE_SPINLOCK(simple_transaction_lock);
481 
482 	if (size > SIMPLE_TRANSACTION_LIMIT - 1)
483 		return ERR_PTR(-EFBIG);
484 
485 	ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
486 	if (!ar)
487 		return ERR_PTR(-ENOMEM);
488 
489 	spin_lock(&simple_transaction_lock);
490 
491 	/* only one write allowed per open */
492 	if (file->private_data) {
493 		spin_unlock(&simple_transaction_lock);
494 		free_page((unsigned long)ar);
495 		return ERR_PTR(-EBUSY);
496 	}
497 
498 	file->private_data = ar;
499 
500 	spin_unlock(&simple_transaction_lock);
501 
502 	if (copy_from_user(ar->data, buf, size))
503 		return ERR_PTR(-EFAULT);
504 
505 	return ar->data;
506 }
507 
508 ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
509 {
510 	struct simple_transaction_argresp *ar = file->private_data;
511 
512 	if (!ar)
513 		return 0;
514 	return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
515 }
516 
517 int simple_transaction_release(struct inode *inode, struct file *file)
518 {
519 	free_page((unsigned long)file->private_data);
520 	return 0;
521 }
522 
523 /* Simple attribute files */
524 
525 struct simple_attr {
526 	u64 (*get)(void *);
527 	void (*set)(void *, u64);
528 	char get_buf[24];	/* enough to store a u64 and "\n\0" */
529 	char set_buf[24];
530 	void *data;
531 	const char *fmt;	/* format for read operation */
532 	struct semaphore sem;	/* protects access to these buffers */
533 };
534 
535 /* simple_attr_open is called by an actual attribute open file operation
536  * to set the attribute specific access operations. */
537 int simple_attr_open(struct inode *inode, struct file *file,
538 		     u64 (*get)(void *), void (*set)(void *, u64),
539 		     const char *fmt)
540 {
541 	struct simple_attr *attr;
542 
543 	attr = kmalloc(sizeof(*attr), GFP_KERNEL);
544 	if (!attr)
545 		return -ENOMEM;
546 
547 	attr->get = get;
548 	attr->set = set;
549 	attr->data = inode->u.generic_ip;
550 	attr->fmt = fmt;
551 	init_MUTEX(&attr->sem);
552 
553 	file->private_data = attr;
554 
555 	return nonseekable_open(inode, file);
556 }
557 
558 int simple_attr_close(struct inode *inode, struct file *file)
559 {
560 	kfree(file->private_data);
561 	return 0;
562 }
563 
564 /* read from the buffer that is filled with the get function */
565 ssize_t simple_attr_read(struct file *file, char __user *buf,
566 			 size_t len, loff_t *ppos)
567 {
568 	struct simple_attr *attr;
569 	size_t size;
570 	ssize_t ret;
571 
572 	attr = file->private_data;
573 
574 	if (!attr->get)
575 		return -EACCES;
576 
577 	down(&attr->sem);
578 	if (*ppos) /* continued read */
579 		size = strlen(attr->get_buf);
580 	else	  /* first read */
581 		size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
582 				 attr->fmt,
583 				 (unsigned long long)attr->get(attr->data));
584 
585 	ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
586 	up(&attr->sem);
587 	return ret;
588 }
589 
590 /* interpret the buffer as a number to call the set function with */
591 ssize_t simple_attr_write(struct file *file, const char __user *buf,
592 			  size_t len, loff_t *ppos)
593 {
594 	struct simple_attr *attr;
595 	u64 val;
596 	size_t size;
597 	ssize_t ret;
598 
599 	attr = file->private_data;
600 
601 	if (!attr->set)
602 		return -EACCES;
603 
604 	down(&attr->sem);
605 	ret = -EFAULT;
606 	size = min(sizeof(attr->set_buf) - 1, len);
607 	if (copy_from_user(attr->set_buf, buf, size))
608 		goto out;
609 
610 	ret = len; /* claim we got the whole input */
611 	attr->set_buf[size] = '\0';
612 	val = simple_strtol(attr->set_buf, NULL, 0);
613 	attr->set(attr->data, val);
614 out:
615 	up(&attr->sem);
616 	return ret;
617 }
618 
619 EXPORT_SYMBOL(dcache_dir_close);
620 EXPORT_SYMBOL(dcache_dir_lseek);
621 EXPORT_SYMBOL(dcache_dir_open);
622 EXPORT_SYMBOL(dcache_readdir);
623 EXPORT_SYMBOL(generic_read_dir);
624 EXPORT_SYMBOL(get_sb_pseudo);
625 EXPORT_SYMBOL(simple_commit_write);
626 EXPORT_SYMBOL(simple_dir_inode_operations);
627 EXPORT_SYMBOL(simple_dir_operations);
628 EXPORT_SYMBOL(simple_empty);
629 EXPORT_SYMBOL(d_alloc_name);
630 EXPORT_SYMBOL(simple_fill_super);
631 EXPORT_SYMBOL(simple_getattr);
632 EXPORT_SYMBOL(simple_link);
633 EXPORT_SYMBOL(simple_lookup);
634 EXPORT_SYMBOL(simple_pin_fs);
635 EXPORT_SYMBOL(simple_prepare_write);
636 EXPORT_SYMBOL(simple_readpage);
637 EXPORT_SYMBOL(simple_release_fs);
638 EXPORT_SYMBOL(simple_rename);
639 EXPORT_SYMBOL(simple_rmdir);
640 EXPORT_SYMBOL(simple_statfs);
641 EXPORT_SYMBOL(simple_sync_file);
642 EXPORT_SYMBOL(simple_unlink);
643 EXPORT_SYMBOL(simple_read_from_buffer);
644 EXPORT_SYMBOL(simple_transaction_get);
645 EXPORT_SYMBOL(simple_transaction_read);
646 EXPORT_SYMBOL(simple_transaction_release);
647 EXPORT_SYMBOL_GPL(simple_attr_open);
648 EXPORT_SYMBOL_GPL(simple_attr_close);
649 EXPORT_SYMBOL_GPL(simple_attr_read);
650 EXPORT_SYMBOL_GPL(simple_attr_write);
651