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 #include <linux/ufs_fs.h> 33 #include <linux/smp_lock.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_kernel(); 58 ino = ufs_inode_by_name(dir, dentry); 59 if (ino) { 60 inode = iget(dir->i_sb, ino); 61 if (!inode) { 62 unlock_kernel(); 63 return ERR_PTR(-EACCES); 64 } 65 } 66 unlock_kernel(); 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 inode = ufs_new_inode(dir, mode); 87 err = PTR_ERR(inode); 88 89 if (!IS_ERR(inode)) { 90 inode->i_op = &ufs_file_inode_operations; 91 inode->i_fop = &ufs_file_operations; 92 inode->i_mapping->a_ops = &ufs_aops; 93 mark_inode_dirty(inode); 94 lock_kernel(); 95 err = ufs_add_nondir(dentry, inode); 96 unlock_kernel(); 97 } 98 UFSD("END: err=%d\n", err); 99 return err; 100 } 101 102 static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev) 103 { 104 struct inode *inode; 105 int err; 106 107 if (!old_valid_dev(rdev)) 108 return -EINVAL; 109 inode = ufs_new_inode(dir, mode); 110 err = PTR_ERR(inode); 111 if (!IS_ERR(inode)) { 112 init_special_inode(inode, mode, rdev); 113 ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev); 114 mark_inode_dirty(inode); 115 lock_kernel(); 116 err = ufs_add_nondir(dentry, inode); 117 unlock_kernel(); 118 } 119 return err; 120 } 121 122 static int ufs_symlink (struct inode * dir, struct dentry * dentry, 123 const char * symname) 124 { 125 struct super_block * sb = dir->i_sb; 126 int err = -ENAMETOOLONG; 127 unsigned l = strlen(symname)+1; 128 struct inode * inode; 129 130 if (l > sb->s_blocksize) 131 goto out_notlocked; 132 133 lock_kernel(); 134 inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO); 135 err = PTR_ERR(inode); 136 if (IS_ERR(inode)) 137 goto out; 138 139 if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) { 140 /* slow symlink */ 141 inode->i_op = &page_symlink_inode_operations; 142 inode->i_mapping->a_ops = &ufs_aops; 143 err = page_symlink(inode, symname, l); 144 if (err) 145 goto out_fail; 146 } else { 147 /* fast symlink */ 148 inode->i_op = &ufs_fast_symlink_inode_operations; 149 memcpy((char*)&UFS_I(inode)->i_u1.i_data,symname,l); 150 inode->i_size = l-1; 151 } 152 mark_inode_dirty(inode); 153 154 err = ufs_add_nondir(dentry, inode); 155 out: 156 unlock_kernel(); 157 out_notlocked: 158 return err; 159 160 out_fail: 161 inode_dec_link_count(inode); 162 iput(inode); 163 goto out; 164 } 165 166 static int ufs_link (struct dentry * old_dentry, struct inode * dir, 167 struct dentry *dentry) 168 { 169 struct inode *inode = old_dentry->d_inode; 170 int error; 171 172 lock_kernel(); 173 if (inode->i_nlink >= UFS_LINK_MAX) { 174 unlock_kernel(); 175 return -EMLINK; 176 } 177 178 inode->i_ctime = CURRENT_TIME_SEC; 179 inode_inc_link_count(inode); 180 atomic_inc(&inode->i_count); 181 182 error = ufs_add_nondir(dentry, inode); 183 unlock_kernel(); 184 return error; 185 } 186 187 static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode) 188 { 189 struct inode * inode; 190 int err = -EMLINK; 191 192 if (dir->i_nlink >= UFS_LINK_MAX) 193 goto out; 194 195 lock_kernel(); 196 inode_inc_link_count(dir); 197 198 inode = ufs_new_inode(dir, S_IFDIR|mode); 199 err = PTR_ERR(inode); 200 if (IS_ERR(inode)) 201 goto out_dir; 202 203 inode->i_op = &ufs_dir_inode_operations; 204 inode->i_fop = &ufs_dir_operations; 205 inode->i_mapping->a_ops = &ufs_aops; 206 207 inode_inc_link_count(inode); 208 209 err = ufs_make_empty(inode, dir); 210 if (err) 211 goto out_fail; 212 213 err = ufs_add_link(dentry, inode); 214 if (err) 215 goto out_fail; 216 unlock_kernel(); 217 218 d_instantiate(dentry, inode); 219 out: 220 return err; 221 222 out_fail: 223 inode_dec_link_count(inode); 224 inode_dec_link_count(inode); 225 iput (inode); 226 out_dir: 227 inode_dec_link_count(dir); 228 unlock_kernel(); 229 goto out; 230 } 231 232 static int ufs_unlink(struct inode *dir, struct dentry *dentry) 233 { 234 struct inode * inode = dentry->d_inode; 235 struct ufs_dir_entry *de; 236 struct page *page; 237 int err = -ENOENT; 238 239 de = ufs_find_entry(dir, dentry, &page); 240 if (!de) 241 goto out; 242 243 err = ufs_delete_entry(dir, de, page); 244 if (err) 245 goto out; 246 247 inode->i_ctime = dir->i_ctime; 248 inode_dec_link_count(inode); 249 err = 0; 250 out: 251 return err; 252 } 253 254 static int ufs_rmdir (struct inode * dir, struct dentry *dentry) 255 { 256 struct inode * inode = dentry->d_inode; 257 int err= -ENOTEMPTY; 258 259 lock_kernel(); 260 if (ufs_empty_dir (inode)) { 261 err = ufs_unlink(dir, dentry); 262 if (!err) { 263 inode->i_size = 0; 264 inode_dec_link_count(inode); 265 inode_dec_link_count(dir); 266 } 267 } 268 unlock_kernel(); 269 return err; 270 } 271 272 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry, 273 struct inode *new_dir, struct dentry *new_dentry) 274 { 275 struct inode *old_inode = old_dentry->d_inode; 276 struct inode *new_inode = new_dentry->d_inode; 277 struct page *dir_page = NULL; 278 struct ufs_dir_entry * dir_de = NULL; 279 struct page *old_page; 280 struct ufs_dir_entry *old_de; 281 int err = -ENOENT; 282 283 old_de = ufs_find_entry(old_dir, old_dentry, &old_page); 284 if (!old_de) 285 goto out; 286 287 if (S_ISDIR(old_inode->i_mode)) { 288 err = -EIO; 289 dir_de = ufs_dotdot(old_inode, &dir_page); 290 if (!dir_de) 291 goto out_old; 292 } 293 294 if (new_inode) { 295 struct page *new_page; 296 struct ufs_dir_entry *new_de; 297 298 err = -ENOTEMPTY; 299 if (dir_de && !ufs_empty_dir(new_inode)) 300 goto out_dir; 301 302 err = -ENOENT; 303 new_de = ufs_find_entry(new_dir, new_dentry, &new_page); 304 if (!new_de) 305 goto out_dir; 306 inode_inc_link_count(old_inode); 307 ufs_set_link(new_dir, new_de, new_page, old_inode); 308 new_inode->i_ctime = CURRENT_TIME_SEC; 309 if (dir_de) 310 drop_nlink(new_inode); 311 inode_dec_link_count(new_inode); 312 } else { 313 if (dir_de) { 314 err = -EMLINK; 315 if (new_dir->i_nlink >= UFS_LINK_MAX) 316 goto out_dir; 317 } 318 inode_inc_link_count(old_inode); 319 err = ufs_add_link(new_dentry, old_inode); 320 if (err) { 321 inode_dec_link_count(old_inode); 322 goto out_dir; 323 } 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 * inode_dec_link_count() will mark the inode dirty. 332 */ 333 old_inode->i_ctime = CURRENT_TIME_SEC; 334 335 ufs_delete_entry(old_dir, old_de, old_page); 336 inode_dec_link_count(old_inode); 337 338 if (dir_de) { 339 ufs_set_link(old_inode, dir_de, dir_page, new_dir); 340 inode_dec_link_count(old_dir); 341 } 342 return 0; 343 344 345 out_dir: 346 if (dir_de) { 347 kunmap(dir_page); 348 page_cache_release(dir_page); 349 } 350 out_old: 351 kunmap(old_page); 352 page_cache_release(old_page); 353 out: 354 return err; 355 } 356 357 const struct inode_operations ufs_dir_inode_operations = { 358 .create = ufs_create, 359 .lookup = ufs_lookup, 360 .link = ufs_link, 361 .unlink = ufs_unlink, 362 .symlink = ufs_symlink, 363 .mkdir = ufs_mkdir, 364 .rmdir = ufs_rmdir, 365 .mknod = ufs_mknod, 366 .rename = ufs_rename, 367 }; 368