minix/fs/mfs/link.c

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