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