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 unlock_ufs(dir->i_sb); 62 if (IS_ERR(inode)) 63 return ERR_CAST(inode); 64 return d_splice_alias(inode, dentry); 65 } 66 67 /* 68 * By the time this is called, we already have created 69 * the directory cache entry for the new file, but it 70 * is so far negative - it has no inode. 71 * 72 * If the create succeeds, we fill in the inode information 73 * with d_instantiate(). 74 */ 75 static int ufs_create (struct inode * dir, struct dentry * dentry, int mode, 76 struct nameidata *nd) 77 { 78 struct inode *inode; 79 int err; 80 81 UFSD("BEGIN\n"); 82 83 inode = ufs_new_inode(dir, mode); 84 err = PTR_ERR(inode); 85 86 if (!IS_ERR(inode)) { 87 inode->i_op = &ufs_file_inode_operations; 88 inode->i_fop = &ufs_file_operations; 89 inode->i_mapping->a_ops = &ufs_aops; 90 mark_inode_dirty(inode); 91 lock_ufs(dir->i_sb); 92 err = ufs_add_nondir(dentry, inode); 93 unlock_ufs(dir->i_sb); 94 } 95 UFSD("END: err=%d\n", err); 96 return err; 97 } 98 99 static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev) 100 { 101 struct inode *inode; 102 int err; 103 104 if (!old_valid_dev(rdev)) 105 return -EINVAL; 106 107 inode = ufs_new_inode(dir, mode); 108 err = PTR_ERR(inode); 109 if (!IS_ERR(inode)) { 110 init_special_inode(inode, mode, rdev); 111 ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev); 112 mark_inode_dirty(inode); 113 lock_ufs(dir->i_sb); 114 err = ufs_add_nondir(dentry, inode); 115 unlock_ufs(dir->i_sb); 116 } 117 return err; 118 } 119 120 static int ufs_symlink (struct inode * dir, struct dentry * dentry, 121 const char * symname) 122 { 123 struct super_block * sb = dir->i_sb; 124 int err = -ENAMETOOLONG; 125 unsigned l = strlen(symname)+1; 126 struct inode * inode; 127 128 if (l > sb->s_blocksize) 129 goto out_notlocked; 130 131 lock_ufs(dir->i_sb); 132 inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO); 133 err = PTR_ERR(inode); 134 if (IS_ERR(inode)) 135 goto out; 136 137 if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) { 138 /* slow symlink */ 139 inode->i_op = &ufs_symlink_inode_operations; 140 inode->i_mapping->a_ops = &ufs_aops; 141 err = page_symlink(inode, symname, l); 142 if (err) 143 goto out_fail; 144 } else { 145 /* fast symlink */ 146 inode->i_op = &ufs_fast_symlink_inode_operations; 147 memcpy(UFS_I(inode)->i_u1.i_symlink, symname, l); 148 inode->i_size = l-1; 149 } 150 mark_inode_dirty(inode); 151 152 err = ufs_add_nondir(dentry, inode); 153 out: 154 unlock_ufs(dir->i_sb); 155 out_notlocked: 156 return err; 157 158 out_fail: 159 inode_dec_link_count(inode); 160 iput(inode); 161 goto out; 162 } 163 164 static int ufs_link (struct dentry * old_dentry, struct inode * dir, 165 struct dentry *dentry) 166 { 167 struct inode *inode = old_dentry->d_inode; 168 int error; 169 170 lock_ufs(dir->i_sb); 171 if (inode->i_nlink >= UFS_LINK_MAX) { 172 unlock_ufs(dir->i_sb); 173 return -EMLINK; 174 } 175 176 inode->i_ctime = CURRENT_TIME_SEC; 177 inode_inc_link_count(inode); 178 ihold(inode); 179 180 error = ufs_add_nondir(dentry, inode); 181 unlock_ufs(dir->i_sb); 182 return error; 183 } 184 185 static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode) 186 { 187 struct inode * inode; 188 int err = -EMLINK; 189 190 if (dir->i_nlink >= UFS_LINK_MAX) 191 goto out; 192 193 lock_ufs(dir->i_sb); 194 inode_inc_link_count(dir); 195 196 inode = ufs_new_inode(dir, S_IFDIR|mode); 197 err = PTR_ERR(inode); 198 if (IS_ERR(inode)) 199 goto out_dir; 200 201 inode->i_op = &ufs_dir_inode_operations; 202 inode->i_fop = &ufs_dir_operations; 203 inode->i_mapping->a_ops = &ufs_aops; 204 205 inode_inc_link_count(inode); 206 207 err = ufs_make_empty(inode, dir); 208 if (err) 209 goto out_fail; 210 211 err = ufs_add_link(dentry, inode); 212 if (err) 213 goto out_fail; 214 unlock_ufs(dir->i_sb); 215 216 d_instantiate(dentry, inode); 217 out: 218 return err; 219 220 out_fail: 221 inode_dec_link_count(inode); 222 inode_dec_link_count(inode); 223 iput (inode); 224 out_dir: 225 inode_dec_link_count(dir); 226 unlock_ufs(dir->i_sb); 227 goto out; 228 } 229 230 static int ufs_unlink(struct inode *dir, struct dentry *dentry) 231 { 232 struct inode * inode = dentry->d_inode; 233 struct ufs_dir_entry *de; 234 struct page *page; 235 int err = -ENOENT; 236 237 de = ufs_find_entry(dir, &dentry->d_name, &page); 238 if (!de) 239 goto out; 240 241 err = ufs_delete_entry(dir, de, page); 242 if (err) 243 goto out; 244 245 inode->i_ctime = dir->i_ctime; 246 inode_dec_link_count(inode); 247 err = 0; 248 out: 249 return err; 250 } 251 252 static int ufs_rmdir (struct inode * dir, struct dentry *dentry) 253 { 254 struct inode * inode = dentry->d_inode; 255 int err= -ENOTEMPTY; 256 257 lock_ufs(dir->i_sb); 258 if (ufs_empty_dir (inode)) { 259 err = ufs_unlink(dir, dentry); 260 if (!err) { 261 inode->i_size = 0; 262 inode_dec_link_count(inode); 263 inode_dec_link_count(dir); 264 } 265 } 266 unlock_ufs(dir->i_sb); 267 return err; 268 } 269 270 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry, 271 struct inode *new_dir, struct dentry *new_dentry) 272 { 273 struct inode *old_inode = old_dentry->d_inode; 274 struct inode *new_inode = new_dentry->d_inode; 275 struct page *dir_page = NULL; 276 struct ufs_dir_entry * dir_de = NULL; 277 struct page *old_page; 278 struct ufs_dir_entry *old_de; 279 int err = -ENOENT; 280 281 old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page); 282 if (!old_de) 283 goto out; 284 285 if (S_ISDIR(old_inode->i_mode)) { 286 err = -EIO; 287 dir_de = ufs_dotdot(old_inode, &dir_page); 288 if (!dir_de) 289 goto out_old; 290 } 291 292 if (new_inode) { 293 struct page *new_page; 294 struct ufs_dir_entry *new_de; 295 296 err = -ENOTEMPTY; 297 if (dir_de && !ufs_empty_dir(new_inode)) 298 goto out_dir; 299 300 err = -ENOENT; 301 new_de = ufs_find_entry(new_dir, &new_dentry->d_name, &new_page); 302 if (!new_de) 303 goto out_dir; 304 ufs_set_link(new_dir, new_de, new_page, old_inode); 305 new_inode->i_ctime = CURRENT_TIME_SEC; 306 if (dir_de) 307 drop_nlink(new_inode); 308 inode_dec_link_count(new_inode); 309 } else { 310 if (dir_de) { 311 err = -EMLINK; 312 if (new_dir->i_nlink >= UFS_LINK_MAX) 313 goto out_dir; 314 } 315 err = ufs_add_link(new_dentry, old_inode); 316 if (err) 317 goto out_dir; 318 if (dir_de) 319 inode_inc_link_count(new_dir); 320 } 321 322 /* 323 * Like most other Unix systems, set the ctime for inodes on a 324 * rename. 325 */ 326 old_inode->i_ctime = CURRENT_TIME_SEC; 327 328 ufs_delete_entry(old_dir, old_de, old_page); 329 mark_inode_dirty(old_inode); 330 331 if (dir_de) { 332 ufs_set_link(old_inode, dir_de, dir_page, new_dir); 333 inode_dec_link_count(old_dir); 334 } 335 return 0; 336 337 338 out_dir: 339 if (dir_de) { 340 kunmap(dir_page); 341 page_cache_release(dir_page); 342 } 343 out_old: 344 kunmap(old_page); 345 page_cache_release(old_page); 346 out: 347 return err; 348 } 349 350 const struct inode_operations ufs_dir_inode_operations = { 351 .create = ufs_create, 352 .lookup = ufs_lookup, 353 .link = ufs_link, 354 .unlink = ufs_unlink, 355 .symlink = ufs_symlink, 356 .mkdir = ufs_mkdir, 357 .rmdir = ufs_rmdir, 358 .mknod = ufs_mknod, 359 .rename = ufs_rename, 360 }; 361