1/* 2 * namei.c - NILFS pathname lookup operations. 3 * 4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Modified for NILFS by Amagai Yoshiji <amagai@osrg.net>, 21 * Ryusuke Konishi <ryusuke@osrg.net> 22 */ 23/* 24 * linux/fs/ext2/namei.c 25 * 26 * Copyright (C) 1992, 1993, 1994, 1995 27 * Remy Card (card@masi.ibp.fr) 28 * Laboratoire MASI - Institut Blaise Pascal 29 * Universite Pierre et Marie Curie (Paris VI) 30 * 31 * from 32 * 33 * linux/fs/minix/namei.c 34 * 35 * Copyright (C) 1991, 1992 Linus Torvalds 36 * 37 * Big-endian to little-endian byte-swapping/bitmaps by 38 * David S. Miller (davem@caip.rutgers.edu), 1995 39 */ 40 41#include <linux/pagemap.h> 42#include "nilfs.h" 43 44 45static inline int nilfs_add_nondir(struct dentry *dentry, struct inode *inode) 46{ 47 int err = nilfs_add_link(dentry, inode); 48 if (!err) { 49 d_instantiate(dentry, inode); 50 return 0; 51 } 52 inode_dec_link_count(inode); 53 iput(inode); 54 return err; 55} 56 57/* 58 * Methods themselves. 59 */ 60 61static struct dentry * 62nilfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 63{ 64 struct inode *inode; 65 ino_t ino; 66 67 if (dentry->d_name.len > NILFS_NAME_LEN) 68 return ERR_PTR(-ENAMETOOLONG); 69 70 ino = nilfs_inode_by_name(dir, &dentry->d_name); 71 inode = NULL; 72 if (ino) { 73 inode = nilfs_iget(dir->i_sb, ino); 74 if (IS_ERR(inode)) 75 return ERR_CAST(inode); 76 } 77 return d_splice_alias(inode, dentry); 78} 79 80struct dentry *nilfs_get_parent(struct dentry *child) 81{ 82 unsigned long ino; 83 struct inode *inode; 84 struct qstr dotdot = {.name = "..", .len = 2}; 85 86 ino = nilfs_inode_by_name(child->d_inode, &dotdot); 87 if (!ino) 88 return ERR_PTR(-ENOENT); 89 90 inode = nilfs_iget(child->d_inode->i_sb, ino); 91 if (IS_ERR(inode)) 92 return ERR_CAST(inode); 93 return d_obtain_alias(inode); 94} 95 96/* 97 * By the time this is called, we already have created 98 * the directory cache entry for the new file, but it 99 * is so far negative - it has no inode. 100 * 101 * If the create succeeds, we fill in the inode information 102 * with d_instantiate(). 103 */ 104static int nilfs_create(struct inode *dir, struct dentry *dentry, int mode, 105 struct nameidata *nd) 106{ 107 struct inode *inode; 108 struct nilfs_transaction_info ti; 109 int err; 110 111 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 112 if (err) 113 return err; 114 inode = nilfs_new_inode(dir, mode); 115 err = PTR_ERR(inode); 116 if (!IS_ERR(inode)) { 117 inode->i_op = &nilfs_file_inode_operations; 118 inode->i_fop = &nilfs_file_operations; 119 inode->i_mapping->a_ops = &nilfs_aops; 120 nilfs_mark_inode_dirty(inode); 121 err = nilfs_add_nondir(dentry, inode); 122 } 123 if (!err) 124 err = nilfs_transaction_commit(dir->i_sb); 125 else 126 nilfs_transaction_abort(dir->i_sb); 127 128 return err; 129} 130 131static int 132nilfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 133{ 134 struct inode *inode; 135 struct nilfs_transaction_info ti; 136 int err; 137 138 if (!new_valid_dev(rdev)) 139 return -EINVAL; 140 141 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 142 if (err) 143 return err; 144 inode = nilfs_new_inode(dir, mode); 145 err = PTR_ERR(inode); 146 if (!IS_ERR(inode)) { 147 init_special_inode(inode, inode->i_mode, rdev); 148 nilfs_mark_inode_dirty(inode); 149 err = nilfs_add_nondir(dentry, inode); 150 } 151 if (!err) 152 err = nilfs_transaction_commit(dir->i_sb); 153 else 154 nilfs_transaction_abort(dir->i_sb); 155 156 return err; 157} 158 159static int nilfs_symlink(struct inode *dir, struct dentry *dentry, 160 const char *symname) 161{ 162 struct nilfs_transaction_info ti; 163 struct super_block *sb = dir->i_sb; 164 unsigned l = strlen(symname)+1; 165 struct inode *inode; 166 int err; 167 168 if (l > sb->s_blocksize) 169 return -ENAMETOOLONG; 170 171 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 172 if (err) 173 return err; 174 175 inode = nilfs_new_inode(dir, S_IFLNK | S_IRWXUGO); 176 err = PTR_ERR(inode); 177 if (IS_ERR(inode)) 178 goto out; 179 180 /* slow symlink */ 181 inode->i_op = &nilfs_symlink_inode_operations; 182 inode->i_mapping->a_ops = &nilfs_aops; 183 err = page_symlink(inode, symname, l); 184 if (err) 185 goto out_fail; 186 187 /* mark_inode_dirty(inode); */ 188 /* page_symlink() do this */ 189 190 err = nilfs_add_nondir(dentry, inode); 191out: 192 if (!err) 193 err = nilfs_transaction_commit(dir->i_sb); 194 else 195 nilfs_transaction_abort(dir->i_sb); 196 197 return err; 198 199out_fail: 200 drop_nlink(inode); 201 nilfs_mark_inode_dirty(inode); 202 iput(inode); 203 goto out; 204} 205 206static int nilfs_link(struct dentry *old_dentry, struct inode *dir, 207 struct dentry *dentry) 208{ 209 struct inode *inode = old_dentry->d_inode; 210 struct nilfs_transaction_info ti; 211 int err; 212 213 if (inode->i_nlink >= NILFS_LINK_MAX) 214 return -EMLINK; 215 216 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 217 if (err) 218 return err; 219 220 inode->i_ctime = CURRENT_TIME; 221 inode_inc_link_count(inode); 222 atomic_inc(&inode->i_count); 223 224 err = nilfs_add_nondir(dentry, inode); 225 if (!err) 226 err = nilfs_transaction_commit(dir->i_sb); 227 else 228 nilfs_transaction_abort(dir->i_sb); 229 230 return err; 231} 232 233static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 234{ 235 struct inode *inode; 236 struct nilfs_transaction_info ti; 237 int err; 238 239 if (dir->i_nlink >= NILFS_LINK_MAX) 240 return -EMLINK; 241 242 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 243 if (err) 244 return err; 245 246 inc_nlink(dir); 247 248 inode = nilfs_new_inode(dir, S_IFDIR | mode); 249 err = PTR_ERR(inode); 250 if (IS_ERR(inode)) 251 goto out_dir; 252 253 inode->i_op = &nilfs_dir_inode_operations; 254 inode->i_fop = &nilfs_dir_operations; 255 inode->i_mapping->a_ops = &nilfs_aops; 256 257 inc_nlink(inode); 258 259 err = nilfs_make_empty(inode, dir); 260 if (err) 261 goto out_fail; 262 263 err = nilfs_add_link(dentry, inode); 264 if (err) 265 goto out_fail; 266 267 nilfs_mark_inode_dirty(inode); 268 d_instantiate(dentry, inode); 269out: 270 if (!err) 271 err = nilfs_transaction_commit(dir->i_sb); 272 else 273 nilfs_transaction_abort(dir->i_sb); 274 275 return err; 276 277out_fail: 278 drop_nlink(inode); 279 drop_nlink(inode); 280 nilfs_mark_inode_dirty(inode); 281 iput(inode); 282out_dir: 283 drop_nlink(dir); 284 nilfs_mark_inode_dirty(dir); 285 goto out; 286} 287 288static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry) 289{ 290 struct inode *inode; 291 struct nilfs_dir_entry *de; 292 struct page *page; 293 int err; 294 295 err = -ENOENT; 296 de = nilfs_find_entry(dir, &dentry->d_name, &page); 297 if (!de) 298 goto out; 299 300 inode = dentry->d_inode; 301 err = -EIO; 302 if (le64_to_cpu(de->inode) != inode->i_ino) 303 goto out; 304 305 if (!inode->i_nlink) { 306 nilfs_warning(inode->i_sb, __func__, 307 "deleting nonexistent file (%lu), %d\n", 308 inode->i_ino, inode->i_nlink); 309 inode->i_nlink = 1; 310 } 311 err = nilfs_delete_entry(de, page); 312 if (err) 313 goto out; 314 315 inode->i_ctime = dir->i_ctime; 316 drop_nlink(inode); 317 err = 0; 318out: 319 return err; 320} 321 322static int nilfs_unlink(struct inode *dir, struct dentry *dentry) 323{ 324 struct nilfs_transaction_info ti; 325 int err; 326 327 err = nilfs_transaction_begin(dir->i_sb, &ti, 0); 328 if (err) 329 return err; 330 331 err = nilfs_do_unlink(dir, dentry); 332 333 if (!err) { 334 nilfs_mark_inode_dirty(dir); 335 nilfs_mark_inode_dirty(dentry->d_inode); 336 err = nilfs_transaction_commit(dir->i_sb); 337 } else 338 nilfs_transaction_abort(dir->i_sb); 339 340 return err; 341} 342 343static int nilfs_rmdir(struct inode *dir, struct dentry *dentry) 344{ 345 struct inode *inode = dentry->d_inode; 346 struct nilfs_transaction_info ti; 347 int err; 348 349 err = nilfs_transaction_begin(dir->i_sb, &ti, 0); 350 if (err) 351 return err; 352 353 err = -ENOTEMPTY; 354 if (nilfs_empty_dir(inode)) { 355 err = nilfs_do_unlink(dir, dentry); 356 if (!err) { 357 inode->i_size = 0; 358 drop_nlink(inode); 359 nilfs_mark_inode_dirty(inode); 360 drop_nlink(dir); 361 nilfs_mark_inode_dirty(dir); 362 } 363 } 364 if (!err) 365 err = nilfs_transaction_commit(dir->i_sb); 366 else 367 nilfs_transaction_abort(dir->i_sb); 368 369 return err; 370} 371 372static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry, 373 struct inode *new_dir, struct dentry *new_dentry) 374{ 375 struct inode *old_inode = old_dentry->d_inode; 376 struct inode *new_inode = new_dentry->d_inode; 377 struct page *dir_page = NULL; 378 struct nilfs_dir_entry *dir_de = NULL; 379 struct page *old_page; 380 struct nilfs_dir_entry *old_de; 381 struct nilfs_transaction_info ti; 382 int err; 383 384 err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1); 385 if (unlikely(err)) 386 return err; 387 388 err = -ENOENT; 389 old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page); 390 if (!old_de) 391 goto out; 392 393 if (S_ISDIR(old_inode->i_mode)) { 394 err = -EIO; 395 dir_de = nilfs_dotdot(old_inode, &dir_page); 396 if (!dir_de) 397 goto out_old; 398 } 399 400 if (new_inode) { 401 struct page *new_page; 402 struct nilfs_dir_entry *new_de; 403 404 err = -ENOTEMPTY; 405 if (dir_de && !nilfs_empty_dir(new_inode)) 406 goto out_dir; 407 408 err = -ENOENT; 409 new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page); 410 if (!new_de) 411 goto out_dir; 412 inc_nlink(old_inode); 413 nilfs_set_link(new_dir, new_de, new_page, old_inode); 414 nilfs_mark_inode_dirty(new_dir); 415 new_inode->i_ctime = CURRENT_TIME; 416 if (dir_de) 417 drop_nlink(new_inode); 418 drop_nlink(new_inode); 419 nilfs_mark_inode_dirty(new_inode); 420 } else { 421 if (dir_de) { 422 err = -EMLINK; 423 if (new_dir->i_nlink >= NILFS_LINK_MAX) 424 goto out_dir; 425 } 426 inc_nlink(old_inode); 427 err = nilfs_add_link(new_dentry, old_inode); 428 if (err) { 429 drop_nlink(old_inode); 430 nilfs_mark_inode_dirty(old_inode); 431 goto out_dir; 432 } 433 if (dir_de) { 434 inc_nlink(new_dir); 435 nilfs_mark_inode_dirty(new_dir); 436 } 437 } 438 439 /* 440 * Like most other Unix systems, set the ctime for inodes on a 441 * rename. 442 */ 443 old_inode->i_ctime = CURRENT_TIME; 444 445 nilfs_delete_entry(old_de, old_page); 446 drop_nlink(old_inode); 447 448 if (dir_de) { 449 nilfs_set_link(old_inode, dir_de, dir_page, new_dir); 450 drop_nlink(old_dir); 451 } 452 nilfs_mark_inode_dirty(old_dir); 453 nilfs_mark_inode_dirty(old_inode); 454 455 err = nilfs_transaction_commit(old_dir->i_sb); 456 return err; 457 458out_dir: 459 if (dir_de) { 460 kunmap(dir_page); 461 page_cache_release(dir_page); 462 } 463out_old: 464 kunmap(old_page); 465 page_cache_release(old_page); 466out: 467 nilfs_transaction_abort(old_dir->i_sb); 468 return err; 469} 470 471const struct inode_operations nilfs_dir_inode_operations = { 472 .create = nilfs_create, 473 .lookup = nilfs_lookup, 474 .link = nilfs_link, 475 .unlink = nilfs_unlink, 476 .symlink = nilfs_symlink, 477 .mkdir = nilfs_mkdir, 478 .rmdir = nilfs_rmdir, 479 .mknod = nilfs_mknod, 480 .rename = nilfs_rename, 481 .setattr = nilfs_setattr, 482 .permission = nilfs_permission, 483}; 484 485const struct inode_operations nilfs_special_inode_operations = { 486 .setattr = nilfs_setattr, 487 .permission = nilfs_permission, 488}; 489 490const struct inode_operations nilfs_symlink_inode_operations = { 491 .readlink = generic_readlink, 492 .follow_link = page_follow_link_light, 493 .put_link = page_put_link, 494}; 495