1 /* 2 * linux/fs/minix/dir.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * minix directory handling functions 7 * 8 * Updated to filesystem version 3 by Daniel Aragones 9 */ 10 11 #include "minix.h" 12 #include <linux/highmem.h> 13 #include <linux/smp_lock.h> 14 15 typedef struct minix_dir_entry minix_dirent; 16 typedef struct minix3_dir_entry minix3_dirent; 17 18 static int minix_readdir(struct file *, void *, filldir_t); 19 20 const struct file_operations minix_dir_operations = { 21 .read = generic_read_dir, 22 .readdir = minix_readdir, 23 .fsync = minix_sync_file, 24 }; 25 26 static inline void dir_put_page(struct page *page) 27 { 28 kunmap(page); 29 page_cache_release(page); 30 } 31 32 /* 33 * Return the offset into page `page_nr' of the last valid 34 * byte in that page, plus one. 35 */ 36 static unsigned 37 minix_last_byte(struct inode *inode, unsigned long page_nr) 38 { 39 unsigned last_byte = PAGE_CACHE_SIZE; 40 41 if (page_nr == (inode->i_size >> PAGE_CACHE_SHIFT)) 42 last_byte = inode->i_size & (PAGE_CACHE_SIZE - 1); 43 return last_byte; 44 } 45 46 static inline unsigned long dir_pages(struct inode *inode) 47 { 48 return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT; 49 } 50 51 static int dir_commit_chunk(struct page *page, unsigned from, unsigned to) 52 { 53 struct inode *dir = (struct inode *)page->mapping->host; 54 int err = 0; 55 page->mapping->a_ops->commit_write(NULL, page, from, to); 56 if (IS_DIRSYNC(dir)) 57 err = write_one_page(page, 1); 58 else 59 unlock_page(page); 60 return err; 61 } 62 63 static struct page * dir_get_page(struct inode *dir, unsigned long n) 64 { 65 struct address_space *mapping = dir->i_mapping; 66 struct page *page = read_mapping_page(mapping, n, NULL); 67 if (!IS_ERR(page)) { 68 kmap(page); 69 if (!PageUptodate(page)) 70 goto fail; 71 } 72 return page; 73 74 fail: 75 dir_put_page(page); 76 return ERR_PTR(-EIO); 77 } 78 79 static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi) 80 { 81 return (void*)((char*)de + sbi->s_dirsize); 82 } 83 84 static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir) 85 { 86 unsigned long pos = filp->f_pos; 87 struct inode *inode = filp->f_path.dentry->d_inode; 88 struct super_block *sb = inode->i_sb; 89 unsigned offset = pos & ~PAGE_CACHE_MASK; 90 unsigned long n = pos >> PAGE_CACHE_SHIFT; 91 unsigned long npages = dir_pages(inode); 92 struct minix_sb_info *sbi = minix_sb(sb); 93 unsigned chunk_size = sbi->s_dirsize; 94 char *name; 95 __u32 inumber; 96 97 lock_kernel(); 98 99 pos = (pos + chunk_size-1) & ~(chunk_size-1); 100 if (pos >= inode->i_size) 101 goto done; 102 103 for ( ; n < npages; n++, offset = 0) { 104 char *p, *kaddr, *limit; 105 struct page *page = dir_get_page(inode, n); 106 107 if (IS_ERR(page)) 108 continue; 109 kaddr = (char *)page_address(page); 110 p = kaddr+offset; 111 limit = kaddr + minix_last_byte(inode, n) - chunk_size; 112 for ( ; p <= limit; p = minix_next_entry(p, sbi)) { 113 if (sbi->s_version == MINIX_V3) { 114 minix3_dirent *de3 = (minix3_dirent *)p; 115 name = de3->name; 116 inumber = de3->inode; 117 } else { 118 minix_dirent *de = (minix_dirent *)p; 119 name = de->name; 120 inumber = de->inode; 121 } 122 if (inumber) { 123 int over; 124 125 unsigned l = strnlen(name, sbi->s_namelen); 126 offset = p - kaddr; 127 over = filldir(dirent, name, l, 128 (n << PAGE_CACHE_SHIFT) | offset, 129 inumber, DT_UNKNOWN); 130 if (over) { 131 dir_put_page(page); 132 goto done; 133 } 134 } 135 } 136 dir_put_page(page); 137 } 138 139 done: 140 filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset; 141 unlock_kernel(); 142 return 0; 143 } 144 145 static inline int namecompare(int len, int maxlen, 146 const char * name, const char * buffer) 147 { 148 if (len < maxlen && buffer[len]) 149 return 0; 150 return !memcmp(name, buffer, len); 151 } 152 153 /* 154 * minix_find_entry() 155 * 156 * finds an entry in the specified directory with the wanted name. It 157 * returns the cache buffer in which the entry was found, and the entry 158 * itself (as a parameter - res_dir). It does NOT read the inode of the 159 * entry - you'll have to do that yourself if you want to. 160 */ 161 minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page) 162 { 163 const char * name = dentry->d_name.name; 164 int namelen = dentry->d_name.len; 165 struct inode * dir = dentry->d_parent->d_inode; 166 struct super_block * sb = dir->i_sb; 167 struct minix_sb_info * sbi = minix_sb(sb); 168 unsigned long n; 169 unsigned long npages = dir_pages(dir); 170 struct page *page = NULL; 171 char *p; 172 173 char *namx; 174 __u32 inumber; 175 *res_page = NULL; 176 177 for (n = 0; n < npages; n++) { 178 char *kaddr, *limit; 179 180 page = dir_get_page(dir, n); 181 if (IS_ERR(page)) 182 continue; 183 184 kaddr = (char*)page_address(page); 185 limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize; 186 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { 187 if (sbi->s_version == MINIX_V3) { 188 minix3_dirent *de3 = (minix3_dirent *)p; 189 namx = de3->name; 190 inumber = de3->inode; 191 } else { 192 minix_dirent *de = (minix_dirent *)p; 193 namx = de->name; 194 inumber = de->inode; 195 } 196 if (!inumber) 197 continue; 198 if (namecompare(namelen, sbi->s_namelen, name, namx)) 199 goto found; 200 } 201 dir_put_page(page); 202 } 203 return NULL; 204 205 found: 206 *res_page = page; 207 return (minix_dirent *)p; 208 } 209 210 int minix_add_link(struct dentry *dentry, struct inode *inode) 211 { 212 struct inode *dir = dentry->d_parent->d_inode; 213 const char * name = dentry->d_name.name; 214 int namelen = dentry->d_name.len; 215 struct super_block * sb = dir->i_sb; 216 struct minix_sb_info * sbi = minix_sb(sb); 217 struct page *page = NULL; 218 unsigned long npages = dir_pages(dir); 219 unsigned long n; 220 char *kaddr, *p; 221 minix_dirent *de; 222 minix3_dirent *de3; 223 unsigned from, to; 224 int err; 225 char *namx = NULL; 226 __u32 inumber; 227 228 /* 229 * We take care of directory expansion in the same loop 230 * This code plays outside i_size, so it locks the page 231 * to protect that region. 232 */ 233 for (n = 0; n <= npages; n++) { 234 char *limit, *dir_end; 235 236 page = dir_get_page(dir, n); 237 err = PTR_ERR(page); 238 if (IS_ERR(page)) 239 goto out; 240 lock_page(page); 241 kaddr = (char*)page_address(page); 242 dir_end = kaddr + minix_last_byte(dir, n); 243 limit = kaddr + PAGE_CACHE_SIZE - sbi->s_dirsize; 244 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { 245 de = (minix_dirent *)p; 246 de3 = (minix3_dirent *)p; 247 if (sbi->s_version == MINIX_V3) { 248 namx = de3->name; 249 inumber = de3->inode; 250 } else { 251 namx = de->name; 252 inumber = de->inode; 253 } 254 if (p == dir_end) { 255 /* We hit i_size */ 256 if (sbi->s_version == MINIX_V3) 257 de3->inode = 0; 258 else 259 de->inode = 0; 260 goto got_it; 261 } 262 if (!inumber) 263 goto got_it; 264 err = -EEXIST; 265 if (namecompare(namelen, sbi->s_namelen, name, namx)) 266 goto out_unlock; 267 } 268 unlock_page(page); 269 dir_put_page(page); 270 } 271 BUG(); 272 return -EINVAL; 273 274 got_it: 275 from = p - (char*)page_address(page); 276 to = from + sbi->s_dirsize; 277 err = page->mapping->a_ops->prepare_write(NULL, page, from, to); 278 if (err) 279 goto out_unlock; 280 memcpy (namx, name, namelen); 281 if (sbi->s_version == MINIX_V3) { 282 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 4); 283 de3->inode = inode->i_ino; 284 } else { 285 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2); 286 de->inode = inode->i_ino; 287 } 288 err = dir_commit_chunk(page, from, to); 289 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; 290 mark_inode_dirty(dir); 291 out_put: 292 dir_put_page(page); 293 out: 294 return err; 295 out_unlock: 296 unlock_page(page); 297 goto out_put; 298 } 299 300 int minix_delete_entry(struct minix_dir_entry *de, struct page *page) 301 { 302 struct address_space *mapping = page->mapping; 303 struct inode *inode = (struct inode*)mapping->host; 304 char *kaddr = page_address(page); 305 unsigned from = (char*)de - kaddr; 306 unsigned to = from + minix_sb(inode->i_sb)->s_dirsize; 307 int err; 308 309 lock_page(page); 310 err = mapping->a_ops->prepare_write(NULL, page, from, to); 311 if (err == 0) { 312 de->inode = 0; 313 err = dir_commit_chunk(page, from, to); 314 } else { 315 unlock_page(page); 316 } 317 dir_put_page(page); 318 inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 319 mark_inode_dirty(inode); 320 return err; 321 } 322 323 int minix_make_empty(struct inode *inode, struct inode *dir) 324 { 325 struct address_space *mapping = inode->i_mapping; 326 struct page *page = grab_cache_page(mapping, 0); 327 struct minix_sb_info *sbi = minix_sb(inode->i_sb); 328 char *kaddr; 329 int err; 330 331 if (!page) 332 return -ENOMEM; 333 err = mapping->a_ops->prepare_write(NULL, page, 0, 2 * sbi->s_dirsize); 334 if (err) { 335 unlock_page(page); 336 goto fail; 337 } 338 339 kaddr = kmap_atomic(page, KM_USER0); 340 memset(kaddr, 0, PAGE_CACHE_SIZE); 341 342 if (sbi->s_version == MINIX_V3) { 343 minix3_dirent *de3 = (minix3_dirent *)kaddr; 344 345 de3->inode = inode->i_ino; 346 strcpy(de3->name, "."); 347 de3 = minix_next_entry(de3, sbi); 348 de3->inode = dir->i_ino; 349 strcpy(de3->name, ".."); 350 } else { 351 minix_dirent *de = (minix_dirent *)kaddr; 352 353 de->inode = inode->i_ino; 354 strcpy(de->name, "."); 355 de = minix_next_entry(de, sbi); 356 de->inode = dir->i_ino; 357 strcpy(de->name, ".."); 358 } 359 kunmap_atomic(kaddr, KM_USER0); 360 361 err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize); 362 fail: 363 page_cache_release(page); 364 return err; 365 } 366 367 /* 368 * routine to check that the specified directory is empty (for rmdir) 369 */ 370 int minix_empty_dir(struct inode * inode) 371 { 372 struct page *page = NULL; 373 unsigned long i, npages = dir_pages(inode); 374 struct minix_sb_info *sbi = minix_sb(inode->i_sb); 375 char *name; 376 __u32 inumber; 377 378 for (i = 0; i < npages; i++) { 379 char *p, *kaddr, *limit; 380 381 page = dir_get_page(inode, i); 382 if (IS_ERR(page)) 383 continue; 384 385 kaddr = (char *)page_address(page); 386 limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize; 387 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { 388 if (sbi->s_version == MINIX_V3) { 389 minix3_dirent *de3 = (minix3_dirent *)p; 390 name = de3->name; 391 inumber = de3->inode; 392 } else { 393 minix_dirent *de = (minix_dirent *)p; 394 name = de->name; 395 inumber = de->inode; 396 } 397 398 if (inumber != 0) { 399 /* check for . and .. */ 400 if (name[0] != '.') 401 goto not_empty; 402 if (!name[1]) { 403 if (inumber != inode->i_ino) 404 goto not_empty; 405 } else if (name[1] != '.') 406 goto not_empty; 407 else if (name[2]) 408 goto not_empty; 409 } 410 } 411 dir_put_page(page); 412 } 413 return 1; 414 415 not_empty: 416 dir_put_page(page); 417 return 0; 418 } 419 420 /* Releases the page */ 421 void minix_set_link(struct minix_dir_entry *de, struct page *page, 422 struct inode *inode) 423 { 424 struct inode *dir = (struct inode*)page->mapping->host; 425 struct minix_sb_info *sbi = minix_sb(dir->i_sb); 426 unsigned from = (char *)de-(char*)page_address(page); 427 unsigned to = from + sbi->s_dirsize; 428 int err; 429 430 lock_page(page); 431 err = page->mapping->a_ops->prepare_write(NULL, page, from, to); 432 if (err == 0) { 433 de->inode = inode->i_ino; 434 err = dir_commit_chunk(page, from, to); 435 } else { 436 unlock_page(page); 437 } 438 dir_put_page(page); 439 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; 440 mark_inode_dirty(dir); 441 } 442 443 struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p) 444 { 445 struct page *page = dir_get_page(dir, 0); 446 struct minix_sb_info *sbi = minix_sb(dir->i_sb); 447 struct minix_dir_entry *de = NULL; 448 449 if (!IS_ERR(page)) { 450 de = minix_next_entry(page_address(page), sbi); 451 *p = page; 452 } 453 return de; 454 } 455 456 ino_t minix_inode_by_name(struct dentry *dentry) 457 { 458 struct page *page; 459 struct minix_dir_entry *de = minix_find_entry(dentry, &page); 460 ino_t res = 0; 461 462 if (de) { 463 res = de->inode; 464 dir_put_page(page); 465 } 466 return res; 467 } 468