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