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 }; 187 188 struct inode_operations simple_dir_inode_operations = { 189 .lookup = simple_lookup, 190 }; 191 192 /* 193 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that 194 * will never be mountable) 195 */ 196 struct super_block * 197 get_sb_pseudo(struct file_system_type *fs_type, char *name, 198 struct super_operations *ops, unsigned long magic) 199 { 200 struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL); 201 static struct super_operations default_ops = {.statfs = simple_statfs}; 202 struct dentry *dentry; 203 struct inode *root; 204 struct qstr d_name = {.name = name, .len = strlen(name)}; 205 206 if (IS_ERR(s)) 207 return s; 208 209 s->s_flags = MS_NOUSER; 210 s->s_maxbytes = ~0ULL; 211 s->s_blocksize = 1024; 212 s->s_blocksize_bits = 10; 213 s->s_magic = magic; 214 s->s_op = ops ? ops : &default_ops; 215 s->s_time_gran = 1; 216 root = new_inode(s); 217 if (!root) 218 goto Enomem; 219 root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR; 220 root->i_uid = root->i_gid = 0; 221 root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME; 222 dentry = d_alloc(NULL, &d_name); 223 if (!dentry) { 224 iput(root); 225 goto Enomem; 226 } 227 dentry->d_sb = s; 228 dentry->d_parent = dentry; 229 d_instantiate(dentry, root); 230 s->s_root = dentry; 231 s->s_flags |= MS_ACTIVE; 232 return s; 233 234 Enomem: 235 up_write(&s->s_umount); 236 deactivate_super(s); 237 return ERR_PTR(-ENOMEM); 238 } 239 240 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 241 { 242 struct inode *inode = old_dentry->d_inode; 243 244 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 245 inode->i_nlink++; 246 atomic_inc(&inode->i_count); 247 dget(dentry); 248 d_instantiate(dentry, inode); 249 return 0; 250 } 251 252 static inline int simple_positive(struct dentry *dentry) 253 { 254 return dentry->d_inode && !d_unhashed(dentry); 255 } 256 257 int simple_empty(struct dentry *dentry) 258 { 259 struct dentry *child; 260 int ret = 0; 261 262 spin_lock(&dcache_lock); 263 list_for_each_entry(child, &dentry->d_subdirs, d_child) 264 if (simple_positive(child)) 265 goto out; 266 ret = 1; 267 out: 268 spin_unlock(&dcache_lock); 269 return ret; 270 } 271 272 int simple_unlink(struct inode *dir, struct dentry *dentry) 273 { 274 struct inode *inode = dentry->d_inode; 275 276 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 277 inode->i_nlink--; 278 dput(dentry); 279 return 0; 280 } 281 282 int simple_rmdir(struct inode *dir, struct dentry *dentry) 283 { 284 if (!simple_empty(dentry)) 285 return -ENOTEMPTY; 286 287 dentry->d_inode->i_nlink--; 288 simple_unlink(dir, dentry); 289 dir->i_nlink--; 290 return 0; 291 } 292 293 int simple_rename(struct inode *old_dir, struct dentry *old_dentry, 294 struct inode *new_dir, struct dentry *new_dentry) 295 { 296 struct inode *inode = old_dentry->d_inode; 297 int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode); 298 299 if (!simple_empty(new_dentry)) 300 return -ENOTEMPTY; 301 302 if (new_dentry->d_inode) { 303 simple_unlink(new_dir, new_dentry); 304 if (they_are_dirs) 305 old_dir->i_nlink--; 306 } else if (they_are_dirs) { 307 old_dir->i_nlink--; 308 new_dir->i_nlink++; 309 } 310 311 old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime = 312 new_dir->i_mtime = inode->i_ctime = CURRENT_TIME; 313 314 return 0; 315 } 316 317 int simple_readpage(struct file *file, struct page *page) 318 { 319 void *kaddr; 320 321 if (PageUptodate(page)) 322 goto out; 323 324 kaddr = kmap_atomic(page, KM_USER0); 325 memset(kaddr, 0, PAGE_CACHE_SIZE); 326 kunmap_atomic(kaddr, KM_USER0); 327 flush_dcache_page(page); 328 SetPageUptodate(page); 329 out: 330 unlock_page(page); 331 return 0; 332 } 333 334 int simple_prepare_write(struct file *file, struct page *page, 335 unsigned from, unsigned to) 336 { 337 if (!PageUptodate(page)) { 338 if (to - from != PAGE_CACHE_SIZE) { 339 void *kaddr = kmap_atomic(page, KM_USER0); 340 memset(kaddr, 0, from); 341 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to); 342 flush_dcache_page(page); 343 kunmap_atomic(kaddr, KM_USER0); 344 } 345 SetPageUptodate(page); 346 } 347 return 0; 348 } 349 350 int simple_commit_write(struct file *file, struct page *page, 351 unsigned offset, unsigned to) 352 { 353 struct inode *inode = page->mapping->host; 354 loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; 355 356 /* 357 * No need to use i_size_read() here, the i_size 358 * cannot change under us because we hold the i_sem. 359 */ 360 if (pos > inode->i_size) 361 i_size_write(inode, pos); 362 set_page_dirty(page); 363 return 0; 364 } 365 366 int simple_fill_super(struct super_block *s, int magic, struct tree_descr *files) 367 { 368 static struct super_operations s_ops = {.statfs = simple_statfs}; 369 struct inode *inode; 370 struct dentry *root; 371 struct dentry *dentry; 372 int i; 373 374 s->s_blocksize = PAGE_CACHE_SIZE; 375 s->s_blocksize_bits = PAGE_CACHE_SHIFT; 376 s->s_magic = magic; 377 s->s_op = &s_ops; 378 s->s_time_gran = 1; 379 380 inode = new_inode(s); 381 if (!inode) 382 return -ENOMEM; 383 inode->i_mode = S_IFDIR | 0755; 384 inode->i_uid = inode->i_gid = 0; 385 inode->i_blksize = PAGE_CACHE_SIZE; 386 inode->i_blocks = 0; 387 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 388 inode->i_op = &simple_dir_inode_operations; 389 inode->i_fop = &simple_dir_operations; 390 root = d_alloc_root(inode); 391 if (!root) { 392 iput(inode); 393 return -ENOMEM; 394 } 395 for (i = 0; !files->name || files->name[0]; i++, files++) { 396 if (!files->name) 397 continue; 398 dentry = d_alloc_name(root, files->name); 399 if (!dentry) 400 goto out; 401 inode = new_inode(s); 402 if (!inode) 403 goto out; 404 inode->i_mode = S_IFREG | files->mode; 405 inode->i_uid = inode->i_gid = 0; 406 inode->i_blksize = PAGE_CACHE_SIZE; 407 inode->i_blocks = 0; 408 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 409 inode->i_fop = files->ops; 410 inode->i_ino = i; 411 d_add(dentry, inode); 412 } 413 s->s_root = root; 414 return 0; 415 out: 416 d_genocide(root); 417 dput(root); 418 return -ENOMEM; 419 } 420 421 static DEFINE_SPINLOCK(pin_fs_lock); 422 423 int simple_pin_fs(char *name, struct vfsmount **mount, int *count) 424 { 425 struct vfsmount *mnt = NULL; 426 spin_lock(&pin_fs_lock); 427 if (unlikely(!*mount)) { 428 spin_unlock(&pin_fs_lock); 429 mnt = do_kern_mount(name, 0, name, NULL); 430 if (IS_ERR(mnt)) 431 return PTR_ERR(mnt); 432 spin_lock(&pin_fs_lock); 433 if (!*mount) 434 *mount = mnt; 435 } 436 mntget(*mount); 437 ++*count; 438 spin_unlock(&pin_fs_lock); 439 mntput(mnt); 440 return 0; 441 } 442 443 void simple_release_fs(struct vfsmount **mount, int *count) 444 { 445 struct vfsmount *mnt; 446 spin_lock(&pin_fs_lock); 447 mnt = *mount; 448 if (!--*count) 449 *mount = NULL; 450 spin_unlock(&pin_fs_lock); 451 mntput(mnt); 452 } 453 454 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos, 455 const void *from, size_t available) 456 { 457 loff_t pos = *ppos; 458 if (pos < 0) 459 return -EINVAL; 460 if (pos >= available) 461 return 0; 462 if (count > available - pos) 463 count = available - pos; 464 if (copy_to_user(to, from + pos, count)) 465 return -EFAULT; 466 *ppos = pos + count; 467 return count; 468 } 469 470 /* 471 * Transaction based IO. 472 * The file expects a single write which triggers the transaction, and then 473 * possibly a read which collects the result - which is stored in a 474 * file-local buffer. 475 */ 476 char *simple_transaction_get(struct file *file, const char __user *buf, size_t size) 477 { 478 struct simple_transaction_argresp *ar; 479 static DEFINE_SPINLOCK(simple_transaction_lock); 480 481 if (size > SIMPLE_TRANSACTION_LIMIT - 1) 482 return ERR_PTR(-EFBIG); 483 484 ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL); 485 if (!ar) 486 return ERR_PTR(-ENOMEM); 487 488 spin_lock(&simple_transaction_lock); 489 490 /* only one write allowed per open */ 491 if (file->private_data) { 492 spin_unlock(&simple_transaction_lock); 493 free_page((unsigned long)ar); 494 return ERR_PTR(-EBUSY); 495 } 496 497 file->private_data = ar; 498 499 spin_unlock(&simple_transaction_lock); 500 501 if (copy_from_user(ar->data, buf, size)) 502 return ERR_PTR(-EFAULT); 503 504 return ar->data; 505 } 506 507 ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) 508 { 509 struct simple_transaction_argresp *ar = file->private_data; 510 511 if (!ar) 512 return 0; 513 return simple_read_from_buffer(buf, size, pos, ar->data, ar->size); 514 } 515 516 int simple_transaction_release(struct inode *inode, struct file *file) 517 { 518 free_page((unsigned long)file->private_data); 519 return 0; 520 } 521 522 EXPORT_SYMBOL(dcache_dir_close); 523 EXPORT_SYMBOL(dcache_dir_lseek); 524 EXPORT_SYMBOL(dcache_dir_open); 525 EXPORT_SYMBOL(dcache_readdir); 526 EXPORT_SYMBOL(generic_read_dir); 527 EXPORT_SYMBOL(get_sb_pseudo); 528 EXPORT_SYMBOL(simple_commit_write); 529 EXPORT_SYMBOL(simple_dir_inode_operations); 530 EXPORT_SYMBOL(simple_dir_operations); 531 EXPORT_SYMBOL(simple_empty); 532 EXPORT_SYMBOL(d_alloc_name); 533 EXPORT_SYMBOL(simple_fill_super); 534 EXPORT_SYMBOL(simple_getattr); 535 EXPORT_SYMBOL(simple_link); 536 EXPORT_SYMBOL(simple_lookup); 537 EXPORT_SYMBOL(simple_pin_fs); 538 EXPORT_SYMBOL(simple_prepare_write); 539 EXPORT_SYMBOL(simple_readpage); 540 EXPORT_SYMBOL(simple_release_fs); 541 EXPORT_SYMBOL(simple_rename); 542 EXPORT_SYMBOL(simple_rmdir); 543 EXPORT_SYMBOL(simple_statfs); 544 EXPORT_SYMBOL(simple_sync_file); 545 EXPORT_SYMBOL(simple_unlink); 546 EXPORT_SYMBOL(simple_read_from_buffer); 547 EXPORT_SYMBOL(simple_transaction_get); 548 EXPORT_SYMBOL(simple_transaction_read); 549 EXPORT_SYMBOL(simple_transaction_release); 550