minix/fs/ext2/link.c

   1 /* Created (MFS based):
   2  *   February 2010 (Evgeniy Ivanov)
   3  */
   4
   5 #include "fs.h"
   6 #include <sys/stat.h>
   7 #include <string.h>
   8 #include <minix/com.h>
   9 #include "buf.h"
  10 #include "inode.h"
  11 #include "super.h"
  12 #include <minix/vfsif.h>
  13 #include <sys/param.h>
  14
  15 #define SAME 1000
  16
  17 static int freesp_inode(struct inode *rip, off_t st, off_t end);
  18 static int remove_dir(struct inode *rldirp, struct inode *rip,
  19         const char *dir_name);
  20 static int unlink_file(struct inode *dirp, struct inode *rip,
  21         const char *file_name);
  22 static off_t nextblock(off_t pos, int blocksize);
  23 static void zeroblock_half(struct inode *i, off_t p, int l);
  24 static void zeroblock_range(struct inode *i, off_t p, off_t h);
  25
  26 /* Args to zeroblock_half() */
  27 #define FIRST_HALF      0
  28 #define LAST_HALF       1
  29
  30
  31 /*===========================================================================*
  32  *                              fs_link                                      *
  33  *===========================================================================*/
  34 int fs_link(ino_t dir_nr, char *name, ino_t ino_nr)
  35 {
  36 /* Perform the link(name1, name2) system call. */
  37
  38   struct inode *ip, *rip;
  39   register int r;
  40   struct inode *new_ip;
  41
  42   /* Temporarily open the file. */
  43   if( (rip = get_inode(fs_dev, ino_nr)) == NULL)
  44           return(EINVAL);
  45
  46   /* Check to see if the file has maximum number of links already. */
  47   r = OK;
  48   if (rip->i_links_count >= USHRT_MAX)
  49           r = EMLINK;
  50   if(rip->i_links_count >= LINK_MAX)
  51           r = EMLINK;
  52
  53   /* Linking to directories is too dangerous to allow. */
  54   if(r == OK)
  55           if( (rip->i_mode & I_TYPE) == I_DIRECTORY)
  56                   r = EPERM;
  57
  58   /* If error with 'name', return the inode. */
  59   if (r != OK) {
  60           put_inode(rip);
  61           return(r);
  62   }
  63
  64   /* Temporarily open the last dir */
  65   if( (ip = get_inode(fs_dev, dir_nr)) == NULL) {
  66         put_inode(rip);
  67         return(EINVAL);
  68   }
  69
  70   if (ip->i_links_count == NO_LINK) {   /* Dir does not actually exist */
  71         put_inode(rip);
  72         put_inode(ip);
  73         return(ENOENT);
  74   }
  75
  76   /* If 'name2' exists in full (even if no space) set 'r' to error. */
  77   if ((new_ip = advance(ip, name)) == NULL) {
  78         r = err_code;
  79         if(r == ENOENT)
  80                 r = OK;
  81   } else {
  82         put_inode(new_ip);
  83         r = EEXIST;
  84   }
  85
  86   /* Try to link. */
  87   if(r == OK)
  88           r = search_dir(ip, name, &rip->i_num, ENTER, rip->i_mode & I_TYPE);
  89
  90   /* If success, register the linking. */
  91   if(r == OK) {
  92           rip->i_links_count++;
  93           rip->i_update |= CTIME;
  94           rip->i_dirt = IN_DIRTY;
  95   }
  96
  97   /* Done.  Release both inodes. */
  98   put_inode(rip);
  99   put_inode(ip);
 100   return(r);
 101 }
 102
 103
 104 /*===========================================================================*
 105  *                              fs_unlink                                    *
 106  *===========================================================================*/
 107 int fs_unlink(ino_t dir_nr, char *name, int call)
 108 {
 109 /* Perform the unlink(name) or rmdir(name) system call. The code for these two
 110  * is almost the same.  They differ only in some condition testing.
 111  */
 112   register struct inode *rip;
 113   struct inode *rldirp;
 114   int r;
 115
 116   /* Temporarily open the dir. */
 117   if((rldirp = get_inode(fs_dev, dir_nr)) == NULL)
 118           return(EINVAL);
 119
 120   /* The last directory exists.  Does the file also exist? */
 121   rip = advance(rldirp, name);
 122   r = err_code;
 123
 124   /* If error, return inode. */
 125   if(r != OK) {
 126         put_inode(rldirp);
 127         return(r);
 128   }
 129   if (rip->i_mountpoint) {
 130         put_inode(rip);
 131         put_inode(rldirp);
 132         return(EBUSY);
 133   }
 134
 135   /* Now test if the call is allowed, separately for unlink() and rmdir(). */
 136   if (call == FSC_UNLINK) {
 137           if( (rip->i_mode & I_TYPE) == I_DIRECTORY) r = EPERM;
 138
 139           /* Actually try to unlink the file; fails if parent is mode 0 etc. */
 140           if (r == OK) r = unlink_file(rldirp, rip, name);
 141   } else {
 142           r = remove_dir(rldirp, rip, name); /* call is RMDIR */
 143   }
 144
 145   /* If unlink was possible, it has been done, otherwise it has not. */
 146   put_inode(rip);
 147   put_inode(rldirp);
 148   return(r);
 149 }
 150
 151
 152 /*===========================================================================*
 153  *                             fs_rdlink                                     *
 154  *===========================================================================*/
 155 ssize_t fs_rdlink(ino_t ino_nr, struct fsdriver_data *data, size_t bytes)
 156 {
 157   struct buf *bp = NULL;       /* buffer containing link text */
 158   char* link_text;             /* either bp->b_data or rip->i_block */
 159   register struct inode *rip;  /* target inode */
 160   register int r;              /* return value */
 161
 162   /* Temporarily open the file. */
 163   if( (rip = get_inode(fs_dev, ino_nr)) == NULL)
 164           return(EINVAL);
 165
 166   if (rip->i_size >= MAX_FAST_SYMLINK_LENGTH) {
 167   /* normal symlink */
 168         if(!(bp = get_block_map(rip, 0))) {
 169                 r = EIO;
 170         } else {
 171                 link_text = b_data(bp);
 172                 r = OK;
 173         }
 174   } else {
 175         /* fast symlink, stored in inode */
 176         link_text = (char*) rip->i_block;
 177         r = OK;
 178   }
 179   if (r == OK) {
 180         /* Passed all checks */
 181         if (bytes > rip->i_size)
 182                 bytes = rip->i_size;
 183         r = fsdriver_copyout(data, 0, link_text, bytes);
 184         put_block(bp);
 185         if (r == OK)
 186                 r = bytes;
 187   }
 188
 189   put_inode(rip);
 190   return(r);
 191 }
 192
 193
 194 /*===========================================================================*
 195  *                              remove_dir                                   *
 196  *===========================================================================*/
 197 static int remove_dir(rldirp, rip, dir_name)
 198 struct inode *rldirp;                   /* parent directory */
 199 struct inode *rip;                      /* directory to be removed */
 200 const char *dir_name;                   /* name of directory to be removed */
 201 {
 202   /* A directory file has to be removed. Five conditions have to met:
 203    *    - The file must be a directory
 204    *    - The directory must be empty (except for . and ..)
 205    *    - The final component of the path must not be . or ..
 206    *    - The directory must not be the root of a mounted file system (VFS)
 207    *    - The directory must not be anybody's root/working directory (VFS)
 208    */
 209   int r;
 210
 211   /* search_dir checks that rip is a directory too. */
 212   if ((r = search_dir(rip, "", NULL, IS_EMPTY, 0)) != OK)
 213         return r;
 214
 215   if (rip->i_num == ROOT_INODE) return(EBUSY); /* can't remove 'root' */
 216
 217   /* Actually try to unlink the file; fails if parent is mode 0 etc. */
 218   if ((r = unlink_file(rldirp, rip, dir_name)) != OK) return r;
 219
 220   /* Unlink . and .. from the dir. The super user can link and unlink any dir,
 221    * so don't make too many assumptions about them.
 222    */
 223   (void) unlink_file(rip, NULL, ".");
 224   (void) unlink_file(rip, NULL, "..");
 225   return(OK);
 226 }
 227
 228
 229 /*===========================================================================*
 230  *                              unlink_file                                  *
 231  *===========================================================================*/
 232 static int unlink_file(dirp, rip, file_name)
 233 struct inode *dirp;             /* parent directory of file */
 234 struct inode *rip;              /* inode of file, may be NULL too. */
 235 const char *file_name;          /* name of file to be removed */
 236 {
 237 /* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
 238
 239   ino_t numb;                   /* inode number */
 240   int   r;
 241
 242   /* If rip is not NULL, it is used to get faster access to the inode. */
 243   if (rip == NULL) {
 244         /* Search for file in directory and try to get its inode. */
 245         err_code = search_dir(dirp, file_name, &numb, LOOK_UP, 0);
 246         if (err_code == OK) rip = get_inode(dirp->i_dev, (int) numb);
 247         if (err_code != OK || rip == NULL) return(err_code);
 248   } else {
 249         dup_inode(rip);         /* inode will be returned with put_inode */
 250   }
 251
 252   r = search_dir(dirp, file_name, NULL, DELETE, 0);
 253
 254   if (r == OK) {
 255         rip->i_links_count--;   /* entry deleted from parent's dir */
 256         rip->i_update |= CTIME;
 257         rip->i_dirt = IN_DIRTY;
 258   }
 259
 260   put_inode(rip);
 261   return(r);
 262 }
 263
 264
 265 /*===========================================================================*
 266  *                              fs_rename                                    *
 267  *===========================================================================*/
 268 int fs_rename(ino_t old_dir_nr, char *old_name, ino_t new_dir_nr,
 269         char *new_name)
 270 {
 271 /* Perform the rename(name1, name2) system call. */
 272   struct inode *old_dirp, *old_ip;      /* ptrs to old dir, file inodes */
 273   struct inode *new_dirp, *new_ip;      /* ptrs to new dir, file inodes */
 274   struct inode *new_superdirp, *next_new_superdirp;
 275   int r = OK;                           /* error flag; initially no error */
 276   int odir, ndir;                       /* TRUE iff {old|new} file is dir */
 277   int same_pdir = 0;                    /* TRUE iff parent dirs are the same */
 278   ino_t numb;
 279
 280   /* Get old dir inode */
 281   if( (old_dirp = get_inode(fs_dev, old_dir_nr)) == NULL)
 282         return(err_code);
 283
 284   old_ip = advance(old_dirp, old_name);
 285   r = err_code;
 286
 287   if (old_ip == NULL) {
 288         put_inode(old_dirp);
 289         return(r);
 290   }
 291
 292   if (old_ip->i_mountpoint) {
 293         put_inode(old_ip);
 294         put_inode(old_dirp);
 295         return(EBUSY);
 296   }
 297
 298   /* Get new dir inode */
 299   if ((new_dirp = get_inode(fs_dev, new_dir_nr)) == NULL){
 300         put_inode(old_ip);
 301         put_inode(old_dirp);
 302         return(err_code);
 303   } else {
 304         if (new_dirp->i_links_count == NO_LINK) { /* Dir does not exist */
 305                 put_inode(old_ip);
 306                 put_inode(old_dirp);
 307                 put_inode(new_dirp);
 308                 return(ENOENT);
 309         }
 310   }
 311
 312   new_ip = advance(new_dirp, new_name); /* not required to exist */
 313
 314   /* If the node does exist, make sure it's not a mountpoint. */
 315   if (new_ip != NULL && new_ip->i_mountpoint) {
 316         put_inode(new_ip);
 317         new_ip = NULL;
 318         r = EBUSY;
 319   }
 320
 321   if(old_ip != NULL)
 322           odir = ((old_ip->i_mode & I_TYPE) == I_DIRECTORY); /* TRUE iff dir */
 323   else
 324           odir = FALSE;
 325
 326   /* If it is ok, check for a variety of possible errors. */
 327   if(r == OK) {
 328         same_pdir = (old_dirp == new_dirp);
 329
 330         /* The old inode must not be a superdirectory of the new last dir. */
 331         if (odir && !same_pdir) {
 332                 dup_inode(new_superdirp = new_dirp);
 333                 while (TRUE) {  /* may hang in a file system loop */
 334                         if (new_superdirp == old_ip) {
 335                                 put_inode(new_superdirp);
 336                                 r = EINVAL;
 337                                 break;
 338                         }
 339                         next_new_superdirp = advance(new_superdirp, "..");
 340
 341                         put_inode(new_superdirp);
 342                         if(next_new_superdirp == new_superdirp) {
 343                                 put_inode(new_superdirp);
 344                                 break;
 345                         }
 346                         if(next_new_superdirp->i_num == ROOT_INODE) {
 347                                 /* imitate that we are back at the root,
 348                                  * cross device checked already on VFS */
 349                                 put_inode(next_new_superdirp);
 350                                 err_code = OK;
 351                                 break;
 352                         }
 353                         new_superdirp = next_new_superdirp;
 354                         if(new_superdirp == NULL) {
 355                                 /* Missing ".." entry.  Assume the worst. */
 356                                 r = EINVAL;
 357                                 break;
 358                         }
 359                 }
 360         }
 361
 362         /* Some tests apply only if the new path exists. */
 363         if(new_ip == NULL) {
 364                 if(odir && (new_dirp->i_links_count >= SHRT_MAX ||
 365                             new_dirp->i_links_count >= LINK_MAX) &&
 366                    !same_pdir && r == OK) {
 367                         r = EMLINK;
 368                 }
 369         } else {
 370                 if(old_ip == new_ip) r = SAME; /* old=new */
 371
 372                 ndir = ((new_ip->i_mode & I_TYPE) == I_DIRECTORY);/* dir ? */
 373                 if(odir == TRUE && ndir == FALSE) r = ENOTDIR;
 374                 if(odir == FALSE && ndir == TRUE) r = EISDIR;
 375         }
 376   }
 377
 378   /* If a process has another root directory than the system root, we might
 379    * "accidently" be moving it's working directory to a place where it's
 380    * root directory isn't a super directory of it anymore. This can make
 381    * the function chroot useless. If chroot will be used often we should
 382    * probably check for it here. */
 383
 384   /* The rename will probably work. Only two things can go wrong now:
 385    * 1. being unable to remove the new file. (when new file already exists)
 386    * 2. being unable to make the new directory entry. (new file doesn't exists)
 387    *     [directory has to grow by one block and cannot because the disk
 388    *      is completely full].
 389    */
 390   if(r == OK) {
 391         if(new_ip != NULL) {
 392                 /* There is already an entry for 'new'. Try to remove it. */
 393                 if(odir)
 394                         r = remove_dir(new_dirp, new_ip, new_name);
 395                 else
 396                         r = unlink_file(new_dirp, new_ip, new_name);
 397         }
 398         /* if r is OK, the rename will succeed, while there is now an
 399          * unused entry in the new parent directory. */
 400   }
 401
 402   if(r == OK) {
 403           /* If the new name will be in the same parent directory as the old
 404            * one, first remove the old name to free an entry for the new name,
 405            * otherwise first try to create the new name entry to make sure
 406            * the rename will succeed.
 407            */
 408         numb = old_ip->i_num;           /* inode number of old file */
 409
 410         if(same_pdir) {
 411                 r = search_dir(old_dirp,old_name, NULL, DELETE, 0);
 412                                                 /* shouldn't go wrong. */
 413                 if(r == OK)
 414                         (void) search_dir(old_dirp, new_name, &numb, ENTER,
 415                                           old_ip->i_mode & I_TYPE);
 416         } else {
 417                 r = search_dir(new_dirp, new_name, &numb, ENTER,
 418                                         old_ip->i_mode & I_TYPE);
 419                 if(r == OK) {
 420                         (void) search_dir(old_dirp, old_name, NULL,
 421                                           DELETE, 0);
 422                 }
 423         }
 424   }
 425   /* If r is OK, the ctime and mtime of old_dirp and new_dirp have been marked
 426    * for update in search_dir. */
 427
 428   if(r == OK && odir && !same_pdir) {
 429         /* Update the .. entry in the directory (still points to old_dirp).*/
 430         numb = new_dirp->i_num;
 431         (void) unlink_file(old_ip, NULL, "..");
 432         if(search_dir(old_ip, "..", &numb, ENTER, I_DIRECTORY) == OK) {
 433                 /* New link created. */
 434                 new_dirp->i_links_count++;
 435                 new_dirp->i_dirt = IN_DIRTY;
 436         }
 437   }
 438
 439   /* Release the inodes. */
 440   put_inode(old_dirp);
 441   put_inode(old_ip);
 442   put_inode(new_dirp);
 443   put_inode(new_ip);
 444   return(r == SAME ? OK : r);
 445 }
 446
 447
 448 /*===========================================================================*
 449  *                              fs_trunc                                     *
 450  *===========================================================================*/
 451 int fs_trunc(ino_t ino_nr, off_t start, off_t end)
 452 {
 453   struct inode *rip;
 454   int r;
 455
 456   if( (rip = find_inode(fs_dev, ino_nr)) == NULL)
 457           return(EINVAL);
 458
 459   if (end == 0)
 460           r = truncate_inode(rip, start);
 461   else
 462           r = freesp_inode(rip, start, end);
 463
 464   return(r);
 465 }
 466
 467
 468 /*===========================================================================*
 469  *                              truncate_inode                               *
 470  *===========================================================================*/
 471 int truncate_inode(rip, newsize)
 472 register struct inode *rip;     /* pointer to inode to be truncated */
 473 off_t newsize;                  /* inode must become this size */
 474 {
 475 /* Set inode to a certain size, freeing any blocks no longer referenced
 476  * and updating the size in the inode. If the inode is extended, the
 477  * extra space is a hole that reads as zeroes.
 478  *
 479  * Nothing special has to happen to file pointers if inode is opened in
 480  * O_APPEND mode, as this is different per fd and is checked when
 481  * writing is done.
 482  */
 483   int r;
 484   mode_t file_type;
 485
 486   discard_preallocated_blocks(rip);
 487
 488   file_type = rip->i_mode & I_TYPE;     /* check to see if file is special */
 489   if (file_type == I_CHAR_SPECIAL || file_type == I_BLOCK_SPECIAL)
 490         return(EINVAL);
 491   if (newsize > rip->i_sp->s_max_size)  /* don't let inode grow too big */
 492         return(EFBIG);
 493
 494   /* Free the actual space if truncating. */
 495   if (newsize < rip->i_size) {
 496         if ((r = freesp_inode(rip, newsize, rip->i_size)) != OK)
 497                 return(r);
 498   }
 499
 500   /* Clear the rest of the last block if expanding. */
 501   if (newsize > rip->i_size) zeroblock_half(rip, rip->i_size, LAST_HALF);
 502
 503   /* Next correct the inode size. */
 504   rip->i_size = newsize;
 505   rip->i_update |= CTIME | MTIME;
 506   rip->i_dirt = IN_DIRTY;
 507
 508   return(OK);
 509 }
 510
 511
 512 /*===========================================================================*
 513  *                              freesp_inode                                 *
 514  *===========================================================================*/
 515 static int freesp_inode(rip, start, end)
 516 register struct inode *rip;     /* pointer to inode to be partly freed */
 517 off_t start, end;               /* range of bytes to free (end uninclusive) */
 518 {
 519 /* Cut an arbitrary hole in an inode. The caller is responsible for checking
 520  * the reasonableness of the inode type of rip. The reason is this is that
 521  * this function can be called for different reasons, for which different
 522  * sets of inode types are reasonable. Adjusting the final size of the inode
 523  * is to be done by the caller too, if wished.
 524  *
 525  * Consumers of this function currently are truncate_inode() (used to
 526  * free indirect and data blocks for any type of inode, but also to
 527  * implement the ftruncate() and truncate() system calls) and the F_FREESP
 528  * fcntl().
 529  */
 530   off_t p, e;
 531   int r;
 532   unsigned short block_size = rip->i_sp->s_block_size;
 533   int zero_last, zero_first;
 534
 535   discard_preallocated_blocks(rip);
 536
 537   if (rip->i_blocks == 0) {
 538   /* Either hole or symlink. Freeing fast symlink using
 539    * write_map() causes segfaults since it doesn't use any
 540    * blocks, but uses i_block[] to store target.
 541    */
 542         return(OK);
 543   }
 544
 545   if(end > rip->i_size)         /* freeing beyond end makes no sense */
 546         end = rip->i_size;
 547   if(end <= start)              /* end is uninclusive, so start<end */
 548         return(EINVAL);
 549
 550   /* If freeing doesn't cross a block boundary, then we may only zero
 551    * a range of the block.
 552    */
 553   zero_last = start % block_size;
 554   zero_first = end % block_size && end < rip->i_size;
 555   if (start/block_size == (end-1)/block_size && (zero_last || zero_first)) {
 556         zeroblock_range(rip, start, end-start);
 557   } else {
 558         /* First zero unused part of partly used blocks. */
 559         if (zero_last)
 560                 zeroblock_half(rip, start, LAST_HALF);
 561         if (zero_first)
 562                 zeroblock_half(rip, end, FIRST_HALF);
 563
 564         /* Now completely free the completely unused blocks.
 565          * write_map() will free unused indirect
 566          * blocks too. Converting the range to block numbers avoids
 567          * overflow on p when doing e.g. 'p += block_size'.
 568          */
 569         e = end / block_size;
 570         if (end == rip->i_size && (end % block_size))
 571                 e++;
 572         for (p = nextblock(start, block_size)/block_size; p < e; p++) {
 573                 if ((r = write_map(rip, p*block_size, NO_BLOCK, WMAP_FREE)) != OK)
 574                         return(r);
 575         }
 576   }
 577
 578   rip->i_update |= CTIME | MTIME;
 579   rip->i_dirt = IN_DIRTY;
 580
 581   return(OK);
 582 }
 583
 584
 585 /*===========================================================================*
 586  *                              nextblock                                    *
 587  *===========================================================================*/
 588 static off_t nextblock(pos, block_size)
 589 off_t pos;
 590 unsigned short block_size;
 591 {
 592 /* Return the first position in the next block after position 'pos'
 593  * (unless this is the first position in the current block).
 594  * This can be done in one expression, but that can overflow pos.
 595  */
 596   off_t p;
 597   p = (pos / block_size) * block_size;
 598   if (pos % block_size) p += block_size;        /* Round up. */
 599   return(p);
 600 }
 601
 602
 603 /*===========================================================================*
 604  *                              zeroblock_half                               *
 605  *===========================================================================*/
 606 static void zeroblock_half(rip, pos, half)
 607 struct inode *rip;
 608 off_t pos;
 609 int half;
 610 {
 611 /* Zero the upper or lower 'half' of a block that holds position 'pos'.
 612  * half can be FIRST_HALF or LAST_HALF.
 613  *
 614  * FIRST_HALF: 0..pos-1 will be zeroed
 615  * LAST_HALF:  pos..blocksize-1 will be zeroed
 616  */
 617   off_t offset, len;
 618
 619   /* Offset of zeroing boundary. */
 620   offset = pos % rip->i_sp->s_block_size;
 621
 622   if(half == LAST_HALF)  {
 623         len = rip->i_sp->s_block_size - offset;
 624   } else {
 625         len = offset;
 626         pos -= offset;
 627   }
 628
 629   zeroblock_range(rip, pos, len);
 630 }
 631
 632
 633 /*===========================================================================*
 634  *                              zeroblock_range                              *
 635  *===========================================================================*/
 636 static void zeroblock_range(rip, pos, len)
 637 struct inode *rip;
 638 off_t pos;
 639 off_t len;
 640 {
 641 /* Zero a range in a block.
 642  * This function is used to zero a segment of a block.
 643  */
 644   struct buf *bp;
 645   off_t offset;
 646
 647   if (!len) return; /* no zeroing to be done. */
 648   if (!(bp = get_block_map(rip, rounddown(pos, rip->i_sp->s_block_size))))
 649         return; /* skip holes */
 650   offset = pos % rip->i_sp->s_block_size;
 651   if (offset + len > rip->i_sp->s_block_size)
 652         panic("zeroblock_range: len too long: %lld", len);
 653   memset(b_data(bp) + offset, 0, len);
 654   lmfs_markdirty(bp);
 655   put_block(bp);
 656 }