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 45 static 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 61 static struct dentry * 62 nilfs_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); 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 80 struct dentry *nilfs_get_parent(struct dentry *child) 81 { 82 unsigned long ino; 83 struct inode *inode; 84 struct dentry dotdot; 85 86 dotdot.d_name.name = ".."; 87 dotdot.d_name.len = 2; 88 89 ino = nilfs_inode_by_name(child->d_inode, &dotdot); 90 if (!ino) 91 return ERR_PTR(-ENOENT); 92 93 inode = nilfs_iget(child->d_inode->i_sb, ino); 94 if (IS_ERR(inode)) 95 return ERR_CAST(inode); 96 return d_obtain_alias(inode); 97 } 98 99 /* 100 * By the time this is called, we already have created 101 * the directory cache entry for the new file, but it 102 * is so far negative - it has no inode. 103 * 104 * If the create succeeds, we fill in the inode information 105 * with d_instantiate(). 106 */ 107 static int nilfs_create(struct inode *dir, struct dentry *dentry, int mode, 108 struct nameidata *nd) 109 { 110 struct inode *inode; 111 struct nilfs_transaction_info ti; 112 int err; 113 114 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 115 if (err) 116 return err; 117 inode = nilfs_new_inode(dir, mode); 118 err = PTR_ERR(inode); 119 if (!IS_ERR(inode)) { 120 inode->i_op = &nilfs_file_inode_operations; 121 inode->i_fop = &nilfs_file_operations; 122 inode->i_mapping->a_ops = &nilfs_aops; 123 mark_inode_dirty(inode); 124 err = nilfs_add_nondir(dentry, inode); 125 } 126 if (!err) 127 err = nilfs_transaction_commit(dir->i_sb); 128 else 129 nilfs_transaction_abort(dir->i_sb); 130 131 return err; 132 } 133 134 static int 135 nilfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 136 { 137 struct inode *inode; 138 struct nilfs_transaction_info ti; 139 int err; 140 141 if (!new_valid_dev(rdev)) 142 return -EINVAL; 143 144 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 145 if (err) 146 return err; 147 inode = nilfs_new_inode(dir, mode); 148 err = PTR_ERR(inode); 149 if (!IS_ERR(inode)) { 150 init_special_inode(inode, inode->i_mode, rdev); 151 mark_inode_dirty(inode); 152 err = nilfs_add_nondir(dentry, inode); 153 } 154 if (!err) 155 err = nilfs_transaction_commit(dir->i_sb); 156 else 157 nilfs_transaction_abort(dir->i_sb); 158 159 return err; 160 } 161 162 static int nilfs_symlink(struct inode *dir, struct dentry *dentry, 163 const char *symname) 164 { 165 struct nilfs_transaction_info ti; 166 struct super_block *sb = dir->i_sb; 167 unsigned l = strlen(symname)+1; 168 struct inode *inode; 169 int err; 170 171 if (l > sb->s_blocksize) 172 return -ENAMETOOLONG; 173 174 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 175 if (err) 176 return err; 177 178 inode = nilfs_new_inode(dir, S_IFLNK | S_IRWXUGO); 179 err = PTR_ERR(inode); 180 if (IS_ERR(inode)) 181 goto out; 182 183 /* slow symlink */ 184 inode->i_op = &nilfs_symlink_inode_operations; 185 inode->i_mapping->a_ops = &nilfs_aops; 186 err = page_symlink(inode, symname, l); 187 if (err) 188 goto out_fail; 189 190 /* mark_inode_dirty(inode); */ 191 /* page_symlink() do this */ 192 193 err = nilfs_add_nondir(dentry, inode); 194 out: 195 if (!err) 196 err = nilfs_transaction_commit(dir->i_sb); 197 else 198 nilfs_transaction_abort(dir->i_sb); 199 200 return err; 201 202 out_fail: 203 drop_nlink(inode); 204 mark_inode_dirty(inode); 205 iput(inode); 206 goto out; 207 } 208 209 static int nilfs_link(struct dentry *old_dentry, struct inode *dir, 210 struct dentry *dentry) 211 { 212 struct inode *inode = old_dentry->d_inode; 213 struct nilfs_transaction_info ti; 214 int err; 215 216 if (inode->i_nlink >= NILFS_LINK_MAX) 217 return -EMLINK; 218 219 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 220 if (err) 221 return err; 222 223 inode->i_ctime = CURRENT_TIME; 224 inode_inc_link_count(inode); 225 atomic_inc(&inode->i_count); 226 227 err = nilfs_add_nondir(dentry, inode); 228 if (!err) 229 err = nilfs_transaction_commit(dir->i_sb); 230 else 231 nilfs_transaction_abort(dir->i_sb); 232 233 return err; 234 } 235 236 static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 237 { 238 struct inode *inode; 239 struct nilfs_transaction_info ti; 240 int err; 241 242 if (dir->i_nlink >= NILFS_LINK_MAX) 243 return -EMLINK; 244 245 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); 246 if (err) 247 return err; 248 249 inc_nlink(dir); 250 251 inode = nilfs_new_inode(dir, S_IFDIR | mode); 252 err = PTR_ERR(inode); 253 if (IS_ERR(inode)) 254 goto out_dir; 255 256 inode->i_op = &nilfs_dir_inode_operations; 257 inode->i_fop = &nilfs_dir_operations; 258 inode->i_mapping->a_ops = &nilfs_aops; 259 260 inc_nlink(inode); 261 262 err = nilfs_make_empty(inode, dir); 263 if (err) 264 goto out_fail; 265 266 err = nilfs_add_link(dentry, inode); 267 if (err) 268 goto out_fail; 269 270 mark_inode_dirty(inode); 271 d_instantiate(dentry, inode); 272 out: 273 if (!err) 274 err = nilfs_transaction_commit(dir->i_sb); 275 else 276 nilfs_transaction_abort(dir->i_sb); 277 278 return err; 279 280 out_fail: 281 drop_nlink(inode); 282 drop_nlink(inode); 283 mark_inode_dirty(inode); 284 iput(inode); 285 out_dir: 286 drop_nlink(dir); 287 mark_inode_dirty(dir); 288 goto out; 289 } 290 291 static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry) 292 { 293 struct inode *inode; 294 struct nilfs_dir_entry *de; 295 struct page *page; 296 int err; 297 298 err = -ENOENT; 299 de = nilfs_find_entry(dir, dentry, &page); 300 if (!de) 301 goto out; 302 303 inode = dentry->d_inode; 304 err = -EIO; 305 if (le64_to_cpu(de->inode) != inode->i_ino) 306 goto out; 307 308 if (!inode->i_nlink) { 309 nilfs_warning(inode->i_sb, __func__, 310 "deleting nonexistent file (%lu), %d\n", 311 inode->i_ino, inode->i_nlink); 312 inode->i_nlink = 1; 313 } 314 err = nilfs_delete_entry(de, page); 315 if (err) 316 goto out; 317 318 inode->i_ctime = dir->i_ctime; 319 drop_nlink(inode); 320 err = 0; 321 out: 322 return err; 323 } 324 325 static int nilfs_unlink(struct inode *dir, struct dentry *dentry) 326 { 327 struct nilfs_transaction_info ti; 328 int err; 329 330 err = nilfs_transaction_begin(dir->i_sb, &ti, 0); 331 if (err) 332 return err; 333 334 err = nilfs_do_unlink(dir, dentry); 335 336 if (!err) { 337 mark_inode_dirty(dentry->d_inode); 338 err = nilfs_transaction_commit(dir->i_sb); 339 } else 340 nilfs_transaction_abort(dir->i_sb); 341 342 return err; 343 } 344 345 static int nilfs_rmdir(struct inode *dir, struct dentry *dentry) 346 { 347 struct inode *inode = dentry->d_inode; 348 struct nilfs_transaction_info ti; 349 int err; 350 351 err = nilfs_transaction_begin(dir->i_sb, &ti, 0); 352 if (err) 353 return err; 354 355 err = -ENOTEMPTY; 356 if (nilfs_empty_dir(inode)) { 357 err = nilfs_do_unlink(dir, dentry); 358 if (!err) { 359 inode->i_size = 0; 360 drop_nlink(inode); 361 mark_inode_dirty(inode); 362 drop_nlink(dir); 363 mark_inode_dirty(dir); 364 } 365 } 366 if (!err) 367 err = nilfs_transaction_commit(dir->i_sb); 368 else 369 nilfs_transaction_abort(dir->i_sb); 370 371 return err; 372 } 373 374 static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry, 375 struct inode *new_dir, struct dentry *new_dentry) 376 { 377 struct inode *old_inode = old_dentry->d_inode; 378 struct inode *new_inode = new_dentry->d_inode; 379 struct page *dir_page = NULL; 380 struct nilfs_dir_entry *dir_de = NULL; 381 struct page *old_page; 382 struct nilfs_dir_entry *old_de; 383 struct nilfs_transaction_info ti; 384 int err; 385 386 err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1); 387 if (unlikely(err)) 388 return err; 389 390 err = -ENOENT; 391 old_de = nilfs_find_entry(old_dir, old_dentry, &old_page); 392 if (!old_de) 393 goto out; 394 395 if (S_ISDIR(old_inode->i_mode)) { 396 err = -EIO; 397 dir_de = nilfs_dotdot(old_inode, &dir_page); 398 if (!dir_de) 399 goto out_old; 400 } 401 402 if (new_inode) { 403 struct page *new_page; 404 struct nilfs_dir_entry *new_de; 405 406 err = -ENOTEMPTY; 407 if (dir_de && !nilfs_empty_dir(new_inode)) 408 goto out_dir; 409 410 err = -ENOENT; 411 new_de = nilfs_find_entry(new_dir, new_dentry, &new_page); 412 if (!new_de) 413 goto out_dir; 414 inc_nlink(old_inode); 415 nilfs_set_link(new_dir, new_de, new_page, old_inode); 416 mark_inode_dirty(new_dir); 417 new_inode->i_ctime = CURRENT_TIME; 418 if (dir_de) 419 drop_nlink(new_inode); 420 drop_nlink(new_inode); 421 mark_inode_dirty(new_inode); 422 } else { 423 if (dir_de) { 424 err = -EMLINK; 425 if (new_dir->i_nlink >= NILFS_LINK_MAX) 426 goto out_dir; 427 } 428 inc_nlink(old_inode); 429 err = nilfs_add_link(new_dentry, old_inode); 430 if (err) { 431 drop_nlink(old_inode); 432 mark_inode_dirty(old_inode); 433 goto out_dir; 434 } 435 if (dir_de) { 436 inc_nlink(new_dir); 437 mark_inode_dirty(new_dir); 438 } 439 } 440 441 /* 442 * Like most other Unix systems, set the ctime for inodes on a 443 * rename. 444 */ 445 old_inode->i_ctime = CURRENT_TIME; 446 447 nilfs_delete_entry(old_de, old_page); 448 drop_nlink(old_inode); 449 450 if (dir_de) { 451 nilfs_set_link(old_inode, dir_de, dir_page, new_dir); 452 drop_nlink(old_dir); 453 mark_inode_dirty(old_dir); 454 } 455 mark_inode_dirty(old_inode); 456 457 err = nilfs_transaction_commit(old_dir->i_sb); 458 return err; 459 460 out_dir: 461 if (dir_de) { 462 kunmap(dir_page); 463 page_cache_release(dir_page); 464 } 465 out_old: 466 kunmap(old_page); 467 page_cache_release(old_page); 468 out: 469 nilfs_transaction_abort(old_dir->i_sb); 470 return err; 471 } 472 473 const struct inode_operations nilfs_dir_inode_operations = { 474 .create = nilfs_create, 475 .lookup = nilfs_lookup, 476 .link = nilfs_link, 477 .unlink = nilfs_unlink, 478 .symlink = nilfs_symlink, 479 .mkdir = nilfs_mkdir, 480 .rmdir = nilfs_rmdir, 481 .mknod = nilfs_mknod, 482 .rename = nilfs_rename, 483 .setattr = nilfs_setattr, 484 .permission = nilfs_permission, 485 }; 486 487 const struct inode_operations nilfs_special_inode_operations = { 488 .setattr = nilfs_setattr, 489 .permission = nilfs_permission, 490 }; 491 492 const struct inode_operations nilfs_symlink_inode_operations = { 493 .readlink = generic_readlink, 494 .follow_link = page_follow_link_light, 495 .put_link = page_put_link, 496 }; 497