bsd/hfs/hfs_link.c

   1 /*
   2  * Copyright (c) 1999-2002 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22
  23
  24 #include <sys/systm.h>
  25 #include <sys/kernel.h>
  26 #include <sys/malloc.h>
  27 #include <sys/mount.h>
  28 #include <sys/namei.h>
  29 #include <sys/stat.h>
  30 #include <sys/vnode.h>
  31 #include <vfs/vfs_support.h>
  32 #include <libkern/libkern.h>
  33
  34 #include "hfs.h"
  35 #include "hfs_catalog.h"
  36 #include "hfs_format.h"
  37 #include "hfs_endian.h"
  38
  39
  40 /*
  41  * Create a new indirect link
  42  *
  43  * An indirect link is a reference to a data node.  The only useable
  44  * fields in the link are the link number, parentID, name and text
  45  * encoding.  All other catalog fields are ignored.
  46  */
  47 static int
  48 createindirectlink(struct hfsmount *hfsmp, u_int32_t linknum,
  49                         u_int32_t linkparid, char *linkName, cnid_t *linkcnid)
  50 {
  51         struct FndrFileInfo *fip;
  52         struct cat_desc desc;
  53         struct cat_attr attr;
  54         int result;
  55
  56         /* Setup the descriptor */
  57         bzero(&desc, sizeof(desc));
  58         desc.cd_nameptr = linkName;
  59         desc.cd_namelen = strlen(linkName);
  60         desc.cd_parentcnid = linkparid;
  61
  62         /* Setup the default attributes */
  63         bzero(&attr, sizeof(attr));
  64
  65         /* links are matched to data nodes by link ID and to volumes by create date */
  66         attr.ca_rdev = linknum;  /* note: cat backend overloads ca_rdev to be the linknum when nlink = 0 */
  67         attr.ca_itime = HFSTOVCB(hfsmp)->vcbCrDate;
  68         attr.ca_mode = S_IFREG;
  69
  70         fip = (struct FndrFileInfo *)&attr.ca_finderinfo;
  71         fip->fdType    = SWAP_BE32 (kHardLinkFileType); /* 'hlnk' */
  72         fip->fdCreator = SWAP_BE32 (kHFSPlusCreator);   /* 'hfs+' */
  73         fip->fdFlags   = SWAP_BE16 (kHasBeenInited);
  74
  75         hfs_global_shared_lock_acquire(hfsmp);
  76         if (hfsmp->jnl) {
  77             if (journal_start_transaction(hfsmp->jnl) != 0) {
  78                         hfs_global_shared_lock_release(hfsmp);
  79                         return EINVAL;
  80             }
  81         }
  82
  83         /* Create the indirect link directly in the catalog */
  84         result = cat_create(hfsmp, &desc, &attr, NULL);
  85
  86         if (result == 0 && linkcnid != NULL)
  87                 *linkcnid = attr.ca_fileid;
  88
  89         if (hfsmp->jnl) {
  90             journal_end_transaction(hfsmp->jnl);
  91         }
  92         hfs_global_shared_lock_release(hfsmp);
  93
  94         return (result);
  95 }
  96
  97
  98 /*
  99  * 2 locks are needed (dvp and vp)
 100  * also need catalog lock
 101  *
 102  * caller's responsibility:
 103  *              componentname cleanup
 104  *              unlocking dvp and vp
 105  */
 106 static int
 107 hfs_makelink(struct hfsmount *hfsmp, struct cnode *cp, struct cnode *dcp,
 108                 struct componentname *cnp)
 109 {
 110         struct proc *p = cnp->cn_proc;
 111         u_int32_t indnodeno = 0;
 112         char inodename[32];
 113         struct cat_desc to_desc;
 114         int newlink = 0;
 115         int retval;
 116
 117
 118         /* We don't allow link nodes in our Private Meta Data folder! */
 119         if (dcp->c_fileid == hfsmp->hfs_privdir_desc.cd_cnid)
 120                 return (EPERM);
 121
 122         if (hfs_freeblks(hfsmp, 0) == 0)
 123                 return (ENOSPC);
 124
 125         /* Lock catalog b-tree */
 126         retval = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p);
 127         if (retval) {
 128             return retval;
 129         }
 130
 131         /*
 132          * If this is a new hardlink then we need to create the data
 133          * node (inode) and replace the original file with a link node.
 134          */
 135         if (cp->c_nlink == 2 && (cp->c_flag & C_HARDLINK) == 0) {
 136                 newlink = 1;
 137                 bzero(&to_desc, sizeof(to_desc));
 138                 to_desc.cd_parentcnid = hfsmp->hfs_privdir_desc.cd_cnid;
 139                 to_desc.cd_cnid = cp->c_fileid;
 140
 141                 do {
 142                         /* get a unique indirect node number */
 143                         indnodeno = ((random() & 0x3fffffff) + 100);
 144                         MAKE_INODE_NAME(inodename, indnodeno);
 145
 146                         /* move source file to data node directory */
 147                         to_desc.cd_nameptr = inodename;
 148                         to_desc.cd_namelen = strlen(inodename);
 149
 150                         retval = cat_rename(hfsmp, &cp->c_desc, &hfsmp->hfs_privdir_desc,
 151                                         &to_desc, NULL);
 152
 153                 } while (retval == EEXIST);
 154                 if (retval)
 155                         goto out;
 156
 157                 /* Replace source file with link node */
 158                 retval = createindirectlink(hfsmp, indnodeno, cp->c_parentcnid,
 159                                 cp->c_desc.cd_nameptr, &cp->c_desc.cd_cnid);
 160                 if (retval) {
 161                         /* put it source file back */
 162                 // XXXdbg
 163                 #if 1
 164                     {
 165                         int err;
 166                                 err = cat_rename(hfsmp, &to_desc, &dcp->c_desc, &cp->c_desc, NULL);
 167                                 if (err)
 168                                         panic("hfs_makelink: error %d from cat_rename backout 1", err);
 169                     }
 170                 #else
 171                         (void) cat_rename(hfsmp, &to_desc, &dcp->c_desc, &cp->c_desc, NULL);
 172                 #endif
 173                         goto out;
 174                 }
 175                 cp->c_rdev = indnodeno;
 176         } else {
 177                 indnodeno = cp->c_rdev;
 178         }
 179
 180         /*
 181          * Create a catalog entry for the new link (parentID + name).
 182          */
 183         retval = createindirectlink(hfsmp, indnodeno, dcp->c_fileid, cnp->cn_nameptr, NULL);
 184         if (retval && newlink) {
 185                 /* Get rid of new link */
 186                 (void) cat_delete(hfsmp, &cp->c_desc, &cp->c_attr);
 187
 188                 /* Put the source file back */
 189         // XXXdbg
 190         #if 1
 191                 {
 192                         int err;
 193                         err = cat_rename(hfsmp, &to_desc, &dcp->c_desc, &cp->c_desc, NULL);
 194                         if (err)
 195                                 panic("hfs_makelink: error %d from cat_rename backout 2", err);
 196                 }
 197         #else
 198                 (void) cat_rename(hfsmp, &to_desc, &dcp->c_desc, &cp->c_desc, NULL);
 199         #endif
 200                 goto out;
 201         }
 202
 203         /*
 204          * Finally, if this is a new hardlink then:
 205          *  - update HFS Private Data dir
 206          *  - mark the cnode as a hard link
 207          */
 208         if (newlink) {
 209                 hfsmp->hfs_privdir_attr.ca_entries++;
 210                 (void)cat_update(hfsmp, &hfsmp->hfs_privdir_desc,
 211                         &hfsmp->hfs_privdir_attr, NULL, NULL);
 212                 hfs_volupdate(hfsmp, VOL_MKFILE, 0);
 213                 cp->c_flag |= (C_CHANGE | C_HARDLINK);
 214         }
 215
 216 out:
 217         /* Unlock catalog b-tree */
 218         (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
 219
 220         return (retval);
 221 }
 222
 223
 224 /*
 225  * link vnode call
 226 #% link         vp      U U U
 227 #% link         tdvp    L U U
 228 #
 229  vop_link {
 230      IN WILLRELE struct vnode *vp;
 231      IN struct vnode *targetPar_vp;
 232      IN struct componentname *cnp;
 233
 234      */
 235 int
 236 hfs_link(ap)
 237         struct vop_link_args /* {
 238                 struct vnode *a_vp;
 239                 struct vnode *a_tdvp;
 240                 struct componentname *a_cnp;
 241         } */ *ap;
 242 {
 243         struct hfsmount *hfsmp;
 244         struct vnode *vp = ap->a_vp;
 245         struct vnode *tdvp = ap->a_tdvp;
 246         struct componentname *cnp = ap->a_cnp;
 247         struct proc *p = cnp->cn_proc;
 248         struct cnode *cp;
 249         struct cnode *tdcp;
 250         struct timeval tv;
 251         int error;
 252
 253         hfsmp = VTOHFS(vp);
 254
 255 #if HFS_DIAGNOSTIC
 256         if ((cnp->cn_flags & HASBUF) == 0)
 257                 panic("hfs_link: no name");
 258 #endif
 259         if (tdvp->v_mount != vp->v_mount) {
 260                 VOP_ABORTOP(tdvp, cnp);
 261                 error = EXDEV;
 262                 goto out2;
 263         }
 264         if (VTOVCB(tdvp)->vcbSigWord != kHFSPlusSigWord)
 265                 return err_link(ap);    /* hfs disks don't support hard links */
 266
 267         if (hfsmp->hfs_private_metadata_dir == 0)
 268                 return err_link(ap);    /* no private metadata dir, no links possible */
 269
 270         if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, p))) {
 271                 VOP_ABORTOP(tdvp, cnp);
 272                 goto out2;
 273         }
 274         cp = VTOC(vp);
 275         tdcp = VTOC(tdvp);
 276
 277         if (cp->c_nlink >= HFS_LINK_MAX) {
 278                 VOP_ABORTOP(tdvp, cnp);
 279                 error = EMLINK;
 280                 goto out1;
 281         }
 282         if (cp->c_flags & (IMMUTABLE | APPEND)) {
 283                 VOP_ABORTOP(tdvp, cnp);
 284                 error = EPERM;
 285                 goto out1;
 286         }
 287         if (vp->v_type == VBLK || vp->v_type == VCHR) {
 288                 VOP_ABORTOP(tdvp, cnp);
 289                 error = EINVAL;  /* cannot link to a special file */
 290                 goto out1;
 291         }
 292
 293         hfs_global_shared_lock_acquire(hfsmp);
 294         if (hfsmp->jnl) {
 295             if (journal_start_transaction(hfsmp->jnl) != 0) {
 296                         hfs_global_shared_lock_release(hfsmp);
 297                         VOP_ABORTOP(tdvp, cnp);
 298                         error = EINVAL;  /* cannot link to a special file */
 299                         goto out1;
 300             }
 301         }
 302
 303         cp->c_nlink++;
 304         cp->c_flag |= C_CHANGE;
 305         tv = time;
 306
 307         error = VOP_UPDATE(vp, &tv, &tv, 1);
 308         if (!error) {
 309                 error = hfs_makelink(hfsmp, cp, tdcp, cnp);
 310         }
 311         if (error) {
 312                 cp->c_nlink--;
 313                 cp->c_flag |= C_CHANGE;
 314         } else {
 315                 /* Update the target directory and volume stats */
 316                 tdcp->c_nlink++;
 317                 tdcp->c_entries++;
 318                 tdcp->c_flag |= C_CHANGE | C_UPDATE;
 319                 tv = time;
 320                 (void) VOP_UPDATE(tdvp, &tv, &tv, 0);
 321
 322                 hfs_volupdate(hfsmp, VOL_MKFILE,
 323                         (tdcp->c_cnid == kHFSRootFolderID));
 324         }
 325
 326         // XXXdbg - need to do this here as well because cp could have changed
 327         error = VOP_UPDATE(vp, &tv, &tv, 1);
 328
 329         FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
 330
 331         if (hfsmp->jnl) {
 332             journal_end_transaction(hfsmp->jnl);
 333         }
 334         hfs_global_shared_lock_release(hfsmp);
 335
 336 out1:
 337         if (tdvp != vp)
 338                 VOP_UNLOCK(vp, 0, p);
 339 out2:
 340         vput(tdvp);
 341         return (error);
 342 }