1 /* 2 * linux/fs/ufs/namei.c 3 * 4 * Migration to usage of "page cache" on May 2006 by 5 * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base. 6 * 7 * Copyright (C) 1998 8 * Daniel Pirkl <daniel.pirkl@email.cz> 9 * Charles University, Faculty of Mathematics and Physics 10 * 11 * from 12 * 13 * linux/fs/ext2/namei.c 14 * 15 * Copyright (C) 1992, 1993, 1994, 1995 16 * Remy Card (card@masi.ibp.fr) 17 * Laboratoire MASI - Institut Blaise Pascal 18 * Universite Pierre et Marie Curie (Paris VI) 19 * 20 * from 21 * 22 * linux/fs/minix/namei.c 23 * 24 * Copyright (C) 1991, 1992 Linus Torvalds 25 * 26 * Big-endian to little-endian byte-swapping/bitmaps by 27 * David S. Miller (davem@caip.rutgers.edu), 1995 28 */ 29 30 #include <linux/time.h> 31 #include <linux/fs.h> 32 33 #include "ufs_fs.h" 34 #include "ufs.h" 35 #include "util.h" 36 37 static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode) 38 { 39 int err = ufs_add_link(dentry, inode); 40 if (!err) { 41 d_instantiate(dentry, inode); 42 return 0; 43 } 44 inode_dec_link_count(inode); 45 iput(inode); 46 return err; 47 } 48 49 static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd) 50 { 51 struct inode * inode = NULL; 52 ino_t ino; 53 54 if (dentry->d_name.len > UFS_MAXNAMLEN) 55 return ERR_PTR(-ENAMETOOLONG); 56 57 lock_ufs(dir->i_sb); 58 ino = ufs_inode_by_name(dir, &dentry->d_name); 59 if (ino) { 60 inode = ufs_iget(dir->i_sb, ino); 61 if (IS_ERR(inode)) { 62 unlock_ufs(dir->i_sb); 63 return ERR_CAST(inode); 64 } 65 } 66 unlock_ufs(dir->i_sb); 67 d_add(dentry, inode); 68 return NULL; 69 } 70 71 /* 72 * By the time this is called, we already have created 73 * the directory cache entry for the new file, but it 74 * is so far negative - it has no inode. 75 * 76 * If the create succeeds, we fill in the inode information 77 * with d_instantiate(). 78 */ 79 static int ufs_create (struct inode * dir, struct dentry * dentry, int mode, 80 struct nameidata *nd) 81 { 82 struct inode *inode; 83 int err; 84 85 UFSD("BEGIN\n"); 86 87 inode = ufs_new_inode(dir, mode); 88 err = PTR_ERR(inode); 89 90 if (!IS_ERR(inode)) { 91 inode->i_op = &ufs_file_inode_operations; 92 inode->i_fop = &ufs_file_operations; 93 inode->i_mapping->a_ops = &ufs_aops; 94 mark_inode_dirty(inode); 95 lock_ufs(dir->i_sb); 96 err = ufs_add_nondir(dentry, inode); 97 unlock_ufs(dir->i_sb); 98 } 99 UFSD("END: err=%d\n", err); 100 return err; 101 } 102 103 static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev) 104 { 105 struct inode *inode; 106 int err; 107 108 if (!old_valid_dev(rdev)) 109 return -EINVAL; 110 111 inode = ufs_new_inode(dir, mode); 112 err = PTR_ERR(inode); 113 if (!IS_ERR(inode)) { 114 init_special_inode(inode, mode, rdev); 115 ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev); 116 mark_inode_dirty(inode); 117 lock_ufs(dir->i_sb); 118 err = ufs_add_nondir(dentry, inode); 119 unlock_ufs(dir->i_sb); 120 } 121 return err; 122 } 123 124 static int ufs_symlink (struct inode * dir, struct dentry * dentry, 125 const char * symname) 126 { 127 struct super_block * sb = dir->i_sb; 128 int err = -ENAMETOOLONG; 129 unsigned l = strlen(symname)+1; 130 struct inode * inode; 131 132 if (l > sb->s_blocksize) 133 goto out_notlocked; 134 135 lock_ufs(dir->i_sb); 136 inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO); 137 err = PTR_ERR(inode); 138 if (IS_ERR(inode)) 139 goto out; 140 141 if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) { 142 /* slow symlink */ 143 inode->i_op = &ufs_symlink_inode_operations; 144 inode->i_mapping->a_ops = &ufs_aops; 145 err = page_symlink(inode, symname, l); 146 if (err) 147 goto out_fail; 148 } else { 149 /* fast symlink */ 150 inode->i_op = &ufs_fast_symlink_inode_operations; 151 memcpy(UFS_I(inode)->i_u1.i_symlink, symname, l); 152 inode->i_size = l-1; 153 } 154 mark_inode_dirty(inode); 155 156 err = ufs_add_nondir(dentry, inode); 157 out: 158 unlock_ufs(dir->i_sb); 159 out_notlocked: 160 return err; 161 162 out_fail: 163 inode_dec_link_count(inode); 164 iput(inode); 165 goto out; 166 } 167 168 static int ufs_link (struct dentry * old_dentry, struct inode * dir, 169 struct dentry *dentry) 170 { 171 struct inode *inode = old_dentry->d_inode; 172 int error; 173 174 lock_ufs(dir->i_sb); 175 if (inode->i_nlink >= UFS_LINK_MAX) { 176 unlock_ufs(dir->i_sb); 177 return -EMLINK; 178 } 179 180 inode->i_ctime = CURRENT_TIME_SEC; 181 inode_inc_link_count(inode); 182 ihold(inode); 183 184 error = ufs_add_nondir(dentry, inode); 185 unlock_ufs(dir->i_sb); 186 return error; 187 } 188 189 static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode) 190 { 191 struct inode * inode; 192 int err = -EMLINK; 193 194 if (dir->i_nlink >= UFS_LINK_MAX) 195 goto out; 196 197 lock_ufs(dir->i_sb); 198 inode_inc_link_count(dir); 199 200 inode = ufs_new_inode(dir, S_IFDIR|mode); 201 err = PTR_ERR(inode); 202 if (IS_ERR(inode)) 203 goto out_dir; 204 205 inode->i_op = &ufs_dir_inode_operations; 206 inode->i_fop = &ufs_dir_operations; 207 inode->i_mapping->a_ops = &ufs_aops; 208 209 inode_inc_link_count(inode); 210 211 err = ufs_make_empty(inode, dir); 212 if (err) 213 goto out_fail; 214 215 err = ufs_add_link(dentry, inode); 216 if (err) 217 goto out_fail; 218 unlock_ufs(dir->i_sb); 219 220 d_instantiate(dentry, inode); 221 out: 222 return err; 223 224 out_fail: 225 inode_dec_link_count(inode); 226 inode_dec_link_count(inode); 227 iput (inode); 228 out_dir: 229 inode_dec_link_count(dir); 230 unlock_ufs(dir->i_sb); 231 goto out; 232 } 233 234 static int ufs_unlink(struct inode *dir, struct dentry *dentry) 235 { 236 struct inode * inode = dentry->d_inode; 237 struct ufs_dir_entry *de; 238 struct page *page; 239 int err = -ENOENT; 240 241 de = ufs_find_entry(dir, &dentry->d_name, &page); 242 if (!de) 243 goto out; 244 245 err = ufs_delete_entry(dir, de, page); 246 if (err) 247 goto out; 248 249 inode->i_ctime = dir->i_ctime; 250 inode_dec_link_count(inode); 251 err = 0; 252 out: 253 return err; 254 } 255 256 static int ufs_rmdir (struct inode * dir, struct dentry *dentry) 257 { 258 struct inode * inode = dentry->d_inode; 259 int err= -ENOTEMPTY; 260 261 dentry_unhash(dentry); 262 263 lock_ufs(dir->i_sb); 264 if (ufs_empty_dir (inode)) { 265 err = ufs_unlink(dir, dentry); 266 if (!err) { 267 inode->i_size = 0; 268 inode_dec_link_count(inode); 269 inode_dec_link_count(dir); 270 } 271 } 272 unlock_ufs(dir->i_sb); 273 return err; 274 } 275 276 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry, 277 struct inode *new_dir, struct dentry *new_dentry) 278 { 279 struct inode *old_inode = old_dentry->d_inode; 280 struct inode *new_inode = new_dentry->d_inode; 281 struct page *dir_page = NULL; 282 struct ufs_dir_entry * dir_de = NULL; 283 struct page *old_page; 284 struct ufs_dir_entry *old_de; 285 int err = -ENOENT; 286 287 old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page); 288 if (!old_de) 289 goto out; 290 291 if (S_ISDIR(old_inode->i_mode)) { 292 err = -EIO; 293 dir_de = ufs_dotdot(old_inode, &dir_page); 294 if (!dir_de) 295 goto out_old; 296 } 297 298 if (new_inode) { 299 struct page *new_page; 300 struct ufs_dir_entry *new_de; 301 302 err = -ENOTEMPTY; 303 if (dir_de && !ufs_empty_dir(new_inode)) 304 goto out_dir; 305 306 err = -ENOENT; 307 new_de = ufs_find_entry(new_dir, &new_dentry->d_name, &new_page); 308 if (!new_de) 309 goto out_dir; 310 ufs_set_link(new_dir, new_de, new_page, old_inode); 311 new_inode->i_ctime = CURRENT_TIME_SEC; 312 if (dir_de) 313 drop_nlink(new_inode); 314 inode_dec_link_count(new_inode); 315 } else { 316 if (dir_de) { 317 err = -EMLINK; 318 if (new_dir->i_nlink >= UFS_LINK_MAX) 319 goto out_dir; 320 } 321 err = ufs_add_link(new_dentry, old_inode); 322 if (err) 323 goto out_dir; 324 if (dir_de) 325 inode_inc_link_count(new_dir); 326 } 327 328 /* 329 * Like most other Unix systems, set the ctime for inodes on a 330 * rename. 331 */ 332 old_inode->i_ctime = CURRENT_TIME_SEC; 333 334 ufs_delete_entry(old_dir, old_de, old_page); 335 mark_inode_dirty(old_inode); 336 337 if (dir_de) { 338 ufs_set_link(old_inode, dir_de, dir_page, new_dir); 339 inode_dec_link_count(old_dir); 340 } 341 return 0; 342 343 344 out_dir: 345 if (dir_de) { 346 kunmap(dir_page); 347 page_cache_release(dir_page); 348 } 349 out_old: 350 kunmap(old_page); 351 page_cache_release(old_page); 352 out: 353 return err; 354 } 355 356 const struct inode_operations ufs_dir_inode_operations = { 357 .create = ufs_create, 358 .lookup = ufs_lookup, 359 .link = ufs_link, 360 .unlink = ufs_unlink, 361 .symlink = ufs_symlink, 362 .mkdir = ufs_mkdir, 363 .rmdir = ufs_rmdir, 364 .mknod = ufs_mknod, 365 .rename = ufs_rename, 366 }; 367