/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1995 Sun Microsystems, Inc. All Rights Reserved * * module: * rename.c * * purpose: * routines to determine whether or not any renames have taken place * and note them (for reconciliation) if we find any * * contents: * find_renames . look for files that have been renamed * find_oldname . (static) find the file we were renamed from * note_rename .. (static) note the rename for subsequent reconciliation * * notes: * the reason renames warrant special attention is because the tree * we have constructed is name based, and a directory rename can * appear as zillions of changes. We attempt to find and deal with * renames prior to doing the difference analysis. * * The only case we deal with here is simple renames. If new links * have been created beneath other directories (i.e. a file has been * moved from one directory to another), the generalized link finding * stuff will deal with it. * * This is still under construction, and to completely deal with * directory renames may require some non-trivial tree restructuring. * There is a whole design note on this subject. In the mean time, * we still detect file renames, so that the user will see them * reported as "mv"s rather than as "ln"s and "rm"s. Until directory * renames are fully implemented, they will instead be handled as * mkdirs, massive links and unlinks, and rmdirs. */ #ident "%W% %E% SMI" #include <stdio.h> #include "filesync.h" #include "database.h" /* local routines */ static struct file *find_oldname(struct file *, struct file *, side_t); static errmask_t note_rename(struct file *, struct file *, struct file *, side_t); /* * routine: * find_renames * * purpose: * recursively perform rename analysis on a directory * * parameters: * file node for the suspected directory * * returns: * error mask * * note: * the basic algorithm here is to search every directory * for files that have been newly created on one side, * and then look to see if they correspond to an identical * file that has been newly deleted on the same side. */ errmask_t find_renames(struct file *fp) { struct file *np, *rp; errmask_t errs = 0; int stype, dtype, btype, side; /* if this isn't a directory, there is nothing to analyze */ if (fp->f_files == 0) return (0); /* look for any files under this directory that may have been renamed */ for (np = fp->f_files; np; np = np->f_next) { btype = np->f_info[OPT_BASE].f_type; stype = np->f_info[OPT_SRC].f_type; dtype = np->f_info[OPT_DST].f_type; /* a rename must be a file that is new on only one side */ if (btype == 0 && stype != dtype && (!stype || !dtype)) { side = stype ? OPT_SRC : OPT_DST; rp = find_oldname(fp, np, side); if (rp) errs |= note_rename(fp, np, rp, side); } } /* recursively examine all my children */ for (np = fp->f_files; np; np = np->f_next) { errs |= find_renames(np); } return (errs); } /* * routine: * find_oldname * * purpose: * to search for an old name for a newly discovered file * * parameters: * file node for the containing directory * file node for the new file * which side the rename is believed to have happened on * * returns: * pointer to likely previous file * 0 no candidate found * * note: * this routine only deals with simple renames within a single * directory. */ static struct file *find_oldname(struct file *dirp, struct file *new, side_t side) { struct file *fp; long maj, min; ino_t inum; off_t size; side_t otherside = (side == OPT_SRC) ? OPT_DST : OPT_SRC; /* figure out what we're looking for */ inum = new->f_info[side].f_ino; maj = new->f_info[side].f_d_maj; min = new->f_info[side].f_d_min; size = new->f_info[side].f_size; /* * search the same directory for any entry that might describe * the previous name of the new file. */ for (fp = dirp->f_files; fp; fp = fp->f_next) { /* previous name on changed side must no longer exist */ if (fp->f_info[side].f_type != 0) continue; /* previous name on the other side must still exist */ if (fp->f_info[otherside].f_type == 0) continue; /* it must describe the same inode as the new file */ if (fp->f_info[OPT_BASE].f_type != new->f_info[side].f_type) continue; /* must be same type */ if (((side == OPT_SRC) ? fp->f_s_inum : fp->f_d_inum) != inum) continue; /* must be same inode # */ if (((side == OPT_SRC) ? fp->f_s_maj : fp->f_d_maj) != maj) continue; /* must be same major # */ if (((side == OPT_SRC) ? fp->f_s_min : fp->f_d_min) != min) continue; /* must be same minor # */ /* * occasionally a prompt delete and create can reuse the * same i-node in the same directory. What we really * want is generation, but that isn't available just * yet, so our poor-man's approximation is the size. * There is little point in checking ownership and * modes, since the fact that it is in the same * directory strongly suggests that it is the same * user who is doing the deleting and creating. */ if (fp->f_info[OPT_BASE].f_size != size) continue; /* looks like we found a match */ return (fp); } /* no joy */ return (0); } /* * routine: * note_rename * * purpose: * to record a discovered rename, so that the reconciliation * phase will deal with it as a rename rather than as link * followed by an unlink. * * parameters: * file node for the containing directory * file node for the new file * file node for the old file * which side the rename is believed to have happened on * * returns: * error mask */ static errmask_t note_rename(struct file *dirp, struct file *new, struct file *old, side_t side) { int dir; errmask_t errs = 0; static char *sidenames[] = {"base", "source", "dest"}; dir = new->f_info[side].f_type == S_IFDIR; if (opt_debug & DBG_ANAL) fprintf(stderr, "ANAL: NOTE RENAME %s %s/%s -> %s/%s on %s\n", dir ? "directory" : "file", dirp->f_name, old->f_name, dirp->f_name, new->f_name, sidenames[side]); /* FIX: we don't deal with directory renames yet */ if (dir) return (0); /* note that a rename has taken place */ if (side == OPT_SRC) { new->f_srcdiffs |= D_RENAME_TO; old->f_srcdiffs |= D_RENAME_FROM; } else { new->f_dstdiffs |= D_RENAME_TO; old->f_dstdiffs |= D_RENAME_FROM; } /* put a link to the old name in the new name */ new->f_previous = old; /* for most files, there is nothing else we have to do */ if (!dir) return (errs); /* * FIX ... someday we are going to have to merge the old and * new children into a single tree, but there are * horrendous backout problems if we are unable to * do the mvdir, so I have postponed this feature. */ return (errs); }
